377fdd99a0e15fe290aeeafbf4040468956b31cd
[ffmpeg.git] / libavformat / utils.c
1 /*
2  * various utility functions for use within Libav
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 #include "avformat.h"
23 #include "avio_internal.h"
24 #include "internal.h"
25 #include "libavcodec/internal.h"
26 #include "libavcodec/bytestream.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/dict.h"
29 #include "libavutil/internal.h"
30 #include "libavutil/pixdesc.h"
31 #include "metadata.h"
32 #include "id3v2.h"
33 #include "libavutil/avassert.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/mathematics.h"
36 #include "libavutil/parseutils.h"
37 #include "libavutil/time.h"
38 #include "riff.h"
39 #include "audiointerleave.h"
40 #include "url.h"
41 #include <stdarg.h>
42 #if CONFIG_NETWORK
43 #include "network.h"
44 #endif
45
46 #undef NDEBUG
47 #include <assert.h>
48
49 /**
50  * @file
51  * various utility functions for use within Libav
52  */
53
54 unsigned avformat_version(void)
55 {
56     return LIBAVFORMAT_VERSION_INT;
57 }
58
59 const char *avformat_configuration(void)
60 {
61     return LIBAV_CONFIGURATION;
62 }
63
64 const char *avformat_license(void)
65 {
66 #define LICENSE_PREFIX "libavformat license: "
67     return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
68 }
69
70 /* an arbitrarily chosen "sane" max packet size -- 50M */
71 #define SANE_CHUNK_SIZE (50000000)
72
73 /*
74  * Read the data in sane-sized chunks and append to pkt.
75  * Return the number of bytes read or an error.
76  */
77 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
78 {
79     int64_t chunk_size = size;
80     int64_t orig_pos   = pkt->pos; // av_grow_packet might reset pos
81     int orig_size      = pkt->size;
82     int ret = 0;
83
84     do {
85         int prev_size = pkt->size;
86         int read_size;
87
88         /*
89          * When the caller requests a lot of data, limit it to the amount left
90          * in file or SANE_CHUNK_SIZE when it is not known
91          */
92         if (size > SANE_CHUNK_SIZE) {
93             int64_t filesize = avio_size(s) - avio_tell(s);
94             chunk_size = FFMAX(filesize, SANE_CHUNK_SIZE);
95         }
96         read_size = FFMIN(size, chunk_size);
97
98         ret = av_grow_packet(pkt, read_size);
99         if (ret < 0)
100             break;
101
102         ret = avio_read(s, pkt->data + prev_size, read_size);
103         if (ret != read_size) {
104             av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
105             break;
106         }
107
108         size -= read_size;
109     } while (size > 0);
110
111     pkt->pos = orig_pos;
112     if (!pkt->size)
113         av_free_packet(pkt);
114     return pkt->size > orig_size ? pkt->size - orig_size : ret;
115 }
116
117 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
118 {
119     av_init_packet(pkt);
120     pkt->data = NULL;
121     pkt->size = 0;
122     pkt->pos  = avio_tell(s);
123
124     return append_packet_chunked(s, pkt, size);
125 }
126
127 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
128 {
129     if (!pkt->size)
130         return av_get_packet(s, pkt, size);
131     return append_packet_chunked(s, pkt, size);
132 }
133
134
135 int av_filename_number_test(const char *filename)
136 {
137     char buf[1024];
138     return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
139 }
140
141 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
142 {
143     AVProbeData lpd = *pd;
144     AVInputFormat *fmt1 = NULL, *fmt;
145     int score, id3 = 0;
146
147     if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
148         int id3len = ff_id3v2_tag_len(lpd.buf);
149         if (lpd.buf_size > id3len + 16) {
150             lpd.buf += id3len;
151             lpd.buf_size -= id3len;
152         }
153         id3 = 1;
154     }
155
156     fmt = NULL;
157     while ((fmt1 = av_iformat_next(fmt1))) {
158         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
159             continue;
160         score = 0;
161         if (fmt1->read_probe) {
162             score = fmt1->read_probe(&lpd);
163         } else if (fmt1->extensions) {
164             if (av_match_ext(lpd.filename, fmt1->extensions)) {
165                 score = AVPROBE_SCORE_EXTENSION;
166             }
167         }
168         if (score > *score_max) {
169             *score_max = score;
170             fmt = fmt1;
171         }else if (score == *score_max)
172             fmt = NULL;
173     }
174
175     /* a hack for files with huge id3v2 tags -- try to guess by file extension. */
176     if (!fmt && is_opened && *score_max < AVPROBE_SCORE_EXTENSION / 2) {
177         while ((fmt = av_iformat_next(fmt)))
178             if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
179                 *score_max = AVPROBE_SCORE_EXTENSION / 2;
180                 break;
181             }
182     }
183
184     if (!fmt && id3 && *score_max < AVPROBE_SCORE_EXTENSION / 2 - 1) {
185         while ((fmt = av_iformat_next(fmt)))
186             if (fmt->extensions && av_match_ext("mp3", fmt->extensions)) {
187                 *score_max = AVPROBE_SCORE_EXTENSION / 2 - 1;
188                 break;
189             }
190     }
191
192     return fmt;
193 }
194
195 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
196     int score=0;
197     return av_probe_input_format2(pd, is_opened, &score);
198 }
199
200 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
201 {
202     static const struct {
203         const char *name; enum AVCodecID id; enum AVMediaType type;
204     } fmt_id_type[] = {
205         { "aac"      , AV_CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
206         { "ac3"      , AV_CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
207         { "dts"      , AV_CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
208         { "eac3"     , AV_CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
209         { "h264"     , AV_CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
210         { "m4v"      , AV_CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
211         { "mp3"      , AV_CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
212         { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
213         { 0 }
214     };
215     AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
216
217     if (fmt) {
218         int i;
219         av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
220                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
221         for (i = 0; fmt_id_type[i].name; i++) {
222             if (!strcmp(fmt->name, fmt_id_type[i].name)) {
223                 st->codec->codec_id   = fmt_id_type[i].id;
224                 st->codec->codec_type = fmt_id_type[i].type;
225                 break;
226             }
227         }
228     }
229     return !!fmt;
230 }
231
232 /************************************************************/
233 /* input media file */
234
235 /** size of probe buffer, for guessing file type from file contents */
236 #define PROBE_BUF_MIN 2048
237 #define PROBE_BUF_MAX (1<<20)
238
239 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
240                           const char *filename, void *logctx,
241                           unsigned int offset, unsigned int max_probe_size)
242 {
243     AVProbeData pd = { filename ? filename : "", NULL, -offset };
244     unsigned char *buf = NULL;
245     int ret = 0, probe_size;
246
247     if (!max_probe_size) {
248         max_probe_size = PROBE_BUF_MAX;
249     } else if (max_probe_size > PROBE_BUF_MAX) {
250         max_probe_size = PROBE_BUF_MAX;
251     } else if (max_probe_size < PROBE_BUF_MIN) {
252         return AVERROR(EINVAL);
253     }
254
255     if (offset >= max_probe_size) {
256         return AVERROR(EINVAL);
257     }
258
259     for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
260         probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
261         int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
262         int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
263
264         if (probe_size < offset) {
265             continue;
266         }
267
268         /* read probe data */
269         if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
270             return ret;
271         if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
272             /* fail if error was not end of file, otherwise, lower score */
273             if (ret != AVERROR_EOF) {
274                 av_free(buf);
275                 return ret;
276             }
277             score = 0;
278             ret = 0;            /* error was end of file, nothing read */
279         }
280         pd.buf_size += ret;
281         pd.buf = &buf[offset];
282
283         memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
284
285         /* guess file format */
286         *fmt = av_probe_input_format2(&pd, 1, &score);
287         if(*fmt){
288             if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
289                 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
290             }else
291                 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
292         }
293     }
294
295     if (!*fmt) {
296         av_free(buf);
297         return AVERROR_INVALIDDATA;
298     }
299
300     /* rewind. reuse probe buffer to avoid seeking */
301     if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
302         av_free(buf);
303
304     return ret;
305 }
306
307 /* open input file and probe the format if necessary */
308 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
309 {
310     int ret;
311     AVProbeData pd = {filename, NULL, 0};
312
313     if (s->pb) {
314         s->flags |= AVFMT_FLAG_CUSTOM_IO;
315         if (!s->iformat)
316             return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
317         else if (s->iformat->flags & AVFMT_NOFILE)
318             return AVERROR(EINVAL);
319         return 0;
320     }
321
322     if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
323         (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
324         return 0;
325
326     if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ,
327                           &s->interrupt_callback, options)) < 0)
328         return ret;
329     if (s->iformat)
330         return 0;
331     return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, s->probesize);
332 }
333
334 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
335                                AVPacketList **plast_pktl){
336     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
337     if (!pktl)
338         return NULL;
339
340     if (*packet_buffer)
341         (*plast_pktl)->next = pktl;
342     else
343         *packet_buffer = pktl;
344
345     /* add the packet in the buffered packet list */
346     *plast_pktl = pktl;
347     pktl->pkt= *pkt;
348     return &pktl->pkt;
349 }
350
351 static int queue_attached_pictures(AVFormatContext *s)
352 {
353     int i;
354     for (i = 0; i < s->nb_streams; i++)
355         if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
356             s->streams[i]->discard < AVDISCARD_ALL) {
357             AVPacket copy = s->streams[i]->attached_pic;
358             copy.buf      = av_buffer_ref(copy.buf);
359             if (!copy.buf)
360                 return AVERROR(ENOMEM);
361
362             add_to_pktbuf(&s->raw_packet_buffer, &copy, &s->raw_packet_buffer_end);
363         }
364     return 0;
365 }
366
367 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
368 {
369     AVFormatContext *s = *ps;
370     int ret = 0;
371     AVDictionary *tmp = NULL;
372     ID3v2ExtraMeta *id3v2_extra_meta = NULL;
373
374     if (!s && !(s = avformat_alloc_context()))
375         return AVERROR(ENOMEM);
376     if (fmt)
377         s->iformat = fmt;
378
379     if (options)
380         av_dict_copy(&tmp, *options, 0);
381
382     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
383         goto fail;
384
385     if ((ret = init_input(s, filename, &tmp)) < 0)
386         goto fail;
387
388     /* check filename in case an image number is expected */
389     if (s->iformat->flags & AVFMT_NEEDNUMBER) {
390         if (!av_filename_number_test(filename)) {
391             ret = AVERROR(EINVAL);
392             goto fail;
393         }
394     }
395
396     s->duration = s->start_time = AV_NOPTS_VALUE;
397     av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
398
399     /* allocate private data */
400     if (s->iformat->priv_data_size > 0) {
401         if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
402             ret = AVERROR(ENOMEM);
403             goto fail;
404         }
405         if (s->iformat->priv_class) {
406             *(const AVClass**)s->priv_data = s->iformat->priv_class;
407             av_opt_set_defaults(s->priv_data);
408             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
409                 goto fail;
410         }
411     }
412
413     /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
414     if (s->pb)
415         ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
416
417     if (s->iformat->read_header)
418         if ((ret = s->iformat->read_header(s)) < 0)
419             goto fail;
420
421     if (id3v2_extra_meta &&
422         (ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
423         goto fail;
424     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
425
426     if ((ret = queue_attached_pictures(s)) < 0)
427         goto fail;
428
429     if (s->pb && !s->data_offset)
430         s->data_offset = avio_tell(s->pb);
431
432     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
433
434     if (options) {
435         av_dict_free(options);
436         *options = tmp;
437     }
438     *ps = s;
439     return 0;
440
441 fail:
442     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
443     av_dict_free(&tmp);
444     if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
445         avio_close(s->pb);
446     avformat_free_context(s);
447     *ps = NULL;
448     return ret;
449 }
450
451 /*******************************************************/
452
453 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
454 {
455     if(st->codec->codec_id == AV_CODEC_ID_PROBE){
456         AVProbeData *pd = &st->probe_data;
457         av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
458         --st->probe_packets;
459
460         if (pkt) {
461             int err;
462             if ((err = av_reallocp(&pd->buf, pd->buf_size + pkt->size +
463                                    AVPROBE_PADDING_SIZE)) < 0)
464                 return err;
465             memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
466             pd->buf_size += pkt->size;
467             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
468         } else {
469             st->probe_packets = 0;
470             if (!pd->buf_size) {
471                 av_log(s, AV_LOG_ERROR, "nothing to probe for stream %d\n",
472                        st->index);
473                 return 0;
474             }
475         }
476
477         if (!st->probe_packets ||
478             av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)) {
479             set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
480             if(st->codec->codec_id != AV_CODEC_ID_PROBE){
481                 pd->buf_size=0;
482                 av_freep(&pd->buf);
483                 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
484             }
485         }
486     }
487     return 0;
488 }
489
490 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
491 {
492     int ret, i, err;
493     AVStream *st;
494
495     for(;;){
496         AVPacketList *pktl = s->raw_packet_buffer;
497
498         if (pktl) {
499             *pkt = pktl->pkt;
500             st = s->streams[pkt->stream_index];
501             if (st->codec->codec_id != AV_CODEC_ID_PROBE || !st->probe_packets ||
502                 s->raw_packet_buffer_remaining_size < pkt->size) {
503                 AVProbeData *pd;
504                 if (st->probe_packets) {
505                     if ((err = probe_codec(s, st, NULL)) < 0)
506                         return err;
507                 }
508                 pd = &st->probe_data;
509                 av_freep(&pd->buf);
510                 pd->buf_size = 0;
511                 s->raw_packet_buffer = pktl->next;
512                 s->raw_packet_buffer_remaining_size += pkt->size;
513                 av_free(pktl);
514                 return 0;
515             }
516         }
517
518         pkt->data = NULL;
519         pkt->size = 0;
520         av_init_packet(pkt);
521         ret= s->iformat->read_packet(s, pkt);
522         if (ret < 0) {
523             if (!pktl || ret == AVERROR(EAGAIN))
524                 return ret;
525             for (i = 0; i < s->nb_streams; i++) {
526                 st = s->streams[i];
527                 if (st->probe_packets) {
528                     if ((err = probe_codec(s, st, NULL)) < 0)
529                         return err;
530                 }
531             }
532             continue;
533         }
534
535         if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
536             (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
537             av_log(s, AV_LOG_WARNING,
538                    "Dropped corrupted packet (stream = %d)\n",
539                    pkt->stream_index);
540             av_free_packet(pkt);
541             continue;
542         }
543
544         st= s->streams[pkt->stream_index];
545
546         switch(st->codec->codec_type){
547         case AVMEDIA_TYPE_VIDEO:
548             if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
549             break;
550         case AVMEDIA_TYPE_AUDIO:
551             if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
552             break;
553         case AVMEDIA_TYPE_SUBTITLE:
554             if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
555             break;
556         }
557
558         if(!pktl && (st->codec->codec_id != AV_CODEC_ID_PROBE ||
559                      !st->probe_packets))
560             return ret;
561
562         add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
563         s->raw_packet_buffer_remaining_size -= pkt->size;
564
565         if ((err = probe_codec(s, st, pkt)) < 0)
566             return err;
567     }
568 }
569
570 /**********************************************************/
571
572 /**
573  * Get the number of samples of an audio frame. Return -1 on error.
574  */
575 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
576 {
577     int frame_size;
578
579     /* give frame_size priority if demuxing */
580     if (!mux && enc->frame_size > 1)
581         return enc->frame_size;
582
583     if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
584         return frame_size;
585
586     /* Fall back on using frame_size if muxing. */
587     if (enc->frame_size > 1)
588         return enc->frame_size;
589
590     return -1;
591 }
592
593
594 /**
595  * Return the frame duration in seconds. Return 0 if not available.
596  */
597 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
598                                AVCodecParserContext *pc, AVPacket *pkt)
599 {
600     int frame_size;
601
602     *pnum = 0;
603     *pden = 0;
604     switch(st->codec->codec_type) {
605     case AVMEDIA_TYPE_VIDEO:
606         if (st->avg_frame_rate.num) {
607             *pnum = st->avg_frame_rate.den;
608             *pden = st->avg_frame_rate.num;
609         } else if(st->time_base.num*1000LL > st->time_base.den) {
610             *pnum = st->time_base.num;
611             *pden = st->time_base.den;
612         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
613             *pnum = st->codec->time_base.num;
614             *pden = st->codec->time_base.den;
615             if (pc && pc->repeat_pict) {
616                 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
617                     *pden /= 1 + pc->repeat_pict;
618                 else
619                     *pnum *= 1 + pc->repeat_pict;
620             }
621             //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
622             //Thus if we have no parser in such case leave duration undefined.
623             if(st->codec->ticks_per_frame>1 && !pc){
624                 *pnum = *pden = 0;
625             }
626         }
627         break;
628     case AVMEDIA_TYPE_AUDIO:
629         frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
630         if (frame_size <= 0 || st->codec->sample_rate <= 0)
631             break;
632         *pnum = frame_size;
633         *pden = st->codec->sample_rate;
634         break;
635     default:
636         break;
637     }
638 }
639
640 static int is_intra_only(enum AVCodecID id)
641 {
642     const AVCodecDescriptor *d = avcodec_descriptor_get(id);
643     if (!d)
644         return 0;
645     if (d->type == AVMEDIA_TYPE_VIDEO && !(d->props & AV_CODEC_PROP_INTRA_ONLY))
646         return 0;
647     return 1;
648 }
649
650 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
651                                       int64_t dts, int64_t pts)
652 {
653     AVStream *st= s->streams[stream_index];
654     AVPacketList *pktl= s->packet_buffer;
655
656     if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
657         return;
658
659     st->first_dts= dts - st->cur_dts;
660     st->cur_dts= dts;
661
662     for(; pktl; pktl= pktl->next){
663         if(pktl->pkt.stream_index != stream_index)
664             continue;
665         //FIXME think more about this check
666         if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
667             pktl->pkt.pts += st->first_dts;
668
669         if(pktl->pkt.dts != AV_NOPTS_VALUE)
670             pktl->pkt.dts += st->first_dts;
671
672         if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
673             st->start_time= pktl->pkt.pts;
674     }
675     if (st->start_time == AV_NOPTS_VALUE)
676         st->start_time = pts;
677 }
678
679 static void update_initial_durations(AVFormatContext *s, AVStream *st,
680                                      int stream_index, int duration)
681 {
682     AVPacketList *pktl= s->packet_buffer;
683     int64_t cur_dts= 0;
684
685     if(st->first_dts != AV_NOPTS_VALUE){
686         cur_dts= st->first_dts;
687         for(; pktl; pktl= pktl->next){
688             if(pktl->pkt.stream_index == stream_index){
689                 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
690                     break;
691                 cur_dts -= duration;
692             }
693         }
694         pktl= s->packet_buffer;
695         st->first_dts = cur_dts;
696     }else if(st->cur_dts)
697         return;
698
699     for(; pktl; pktl= pktl->next){
700         if(pktl->pkt.stream_index != stream_index)
701             continue;
702         if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
703            && !pktl->pkt.duration){
704             pktl->pkt.dts= cur_dts;
705             if(!st->codec->has_b_frames)
706                 pktl->pkt.pts= cur_dts;
707             cur_dts += duration;
708             if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
709                 pktl->pkt.duration = duration;
710         }else
711             break;
712     }
713     if(st->first_dts == AV_NOPTS_VALUE)
714         st->cur_dts= cur_dts;
715 }
716
717 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
718                                AVCodecParserContext *pc, AVPacket *pkt)
719 {
720     int num, den, presentation_delayed, delay, i;
721     int64_t offset;
722
723     if (s->flags & AVFMT_FLAG_NOFILLIN)
724         return;
725
726     if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
727         pkt->dts= AV_NOPTS_VALUE;
728
729     /* do we have a video B-frame ? */
730     delay= st->codec->has_b_frames;
731     presentation_delayed = 0;
732
733     /* XXX: need has_b_frame, but cannot get it if the codec is
734         not initialized */
735     if (delay &&
736         pc && pc->pict_type != AV_PICTURE_TYPE_B)
737         presentation_delayed = 1;
738
739     if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
740         st->pts_wrap_bits < 63 &&
741         pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
742         pkt->dts -= 1LL<<st->pts_wrap_bits;
743     }
744
745     // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
746     // we take the conservative approach and discard both
747     // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
748     if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
749         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
750         pkt->dts= pkt->pts= AV_NOPTS_VALUE;
751     }
752
753     if (pkt->duration == 0 && st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
754         ff_compute_frame_duration(&num, &den, st, pc, pkt);
755         if (den && num) {
756             pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
757
758             if(pkt->duration != 0 && s->packet_buffer)
759                 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
760         }
761     }
762
763     /* correct timestamps with byte offset if demuxers only have timestamps
764        on packet boundaries */
765     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
766         /* this will estimate bitrate based on this frame's duration and size */
767         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
768         if(pkt->pts != AV_NOPTS_VALUE)
769             pkt->pts += offset;
770         if(pkt->dts != AV_NOPTS_VALUE)
771             pkt->dts += offset;
772     }
773
774     /* This may be redundant, but it should not hurt. */
775     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
776         presentation_delayed = 1;
777
778     av_dlog(NULL,
779             "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n",
780             presentation_delayed, pkt->pts, pkt->dts, st->cur_dts,
781             pkt->stream_index, pc);
782     /* interpolate PTS and DTS if they are not present */
783     //We skip H264 currently because delay and has_b_frames are not reliably set
784     if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
785         if (presentation_delayed) {
786             /* DTS = decompression timestamp */
787             /* PTS = presentation timestamp */
788             if (pkt->dts == AV_NOPTS_VALUE)
789                 pkt->dts = st->last_IP_pts;
790             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
791             if (pkt->dts == AV_NOPTS_VALUE)
792                 pkt->dts = st->cur_dts;
793
794             /* this is tricky: the dts must be incremented by the duration
795             of the frame we are displaying, i.e. the last I- or P-frame */
796             if (st->last_IP_duration == 0)
797                 st->last_IP_duration = pkt->duration;
798             if(pkt->dts != AV_NOPTS_VALUE)
799                 st->cur_dts = pkt->dts + st->last_IP_duration;
800             st->last_IP_duration  = pkt->duration;
801             st->last_IP_pts= pkt->pts;
802             /* cannot compute PTS if not present (we can compute it only
803             by knowing the future */
804         } else if (pkt->pts != AV_NOPTS_VALUE ||
805                    pkt->dts != AV_NOPTS_VALUE ||
806                    pkt->duration              ||
807                    st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
808             int duration = pkt->duration;
809             if (!duration && st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
810                 ff_compute_frame_duration(&num, &den, st, pc, pkt);
811                 if (den && num) {
812                     duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den,
813                                                  den * (int64_t)st->time_base.num,
814                                                  AV_ROUND_DOWN);
815                     if (duration != 0 && s->packet_buffer) {
816                         update_initial_durations(s, st, pkt->stream_index,
817                                                  duration);
818                     }
819                 }
820             }
821
822             if (pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE ||
823                 duration) {
824                 /* presentation is not delayed : PTS and DTS are the same */
825                 if (pkt->pts == AV_NOPTS_VALUE)
826                     pkt->pts = pkt->dts;
827                 update_initial_timestamps(s, pkt->stream_index, pkt->pts,
828                                           pkt->pts);
829                 if (pkt->pts == AV_NOPTS_VALUE)
830                     pkt->pts = st->cur_dts;
831                 pkt->dts = pkt->pts;
832                 if (pkt->pts != AV_NOPTS_VALUE)
833                     st->cur_dts = pkt->pts + duration;
834             }
835         }
836     }
837
838     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
839         st->pts_buffer[0]= pkt->pts;
840         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
841             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
842         if(pkt->dts == AV_NOPTS_VALUE)
843             pkt->dts= st->pts_buffer[0];
844         if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
845             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
846         }
847         if(pkt->dts > st->cur_dts)
848             st->cur_dts = pkt->dts;
849     }
850
851     av_dlog(NULL,
852             "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n",
853             presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
854
855     /* update flags */
856     if (is_intra_only(st->codec->codec_id))
857         pkt->flags |= AV_PKT_FLAG_KEY;
858     if (pc)
859         pkt->convergence_duration = pc->convergence_duration;
860 }
861
862 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
863 {
864     while (*pkt_buf) {
865         AVPacketList *pktl = *pkt_buf;
866         *pkt_buf = pktl->next;
867         av_free_packet(&pktl->pkt);
868         av_freep(&pktl);
869     }
870     *pkt_buf_end = NULL;
871 }
872
873 /**
874  * Parse a packet, add all split parts to parse_queue
875  *
876  * @param pkt packet to parse, NULL when flushing the parser at end of stream
877  */
878 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
879 {
880     AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
881     AVStream     *st = s->streams[stream_index];
882     uint8_t    *data = pkt ? pkt->data : NULL;
883     int         size = pkt ? pkt->size : 0;
884     int ret = 0, got_output = 0;
885
886     if (!pkt) {
887         av_init_packet(&flush_pkt);
888         pkt = &flush_pkt;
889         got_output = 1;
890     }
891
892     while (size > 0 || (pkt == &flush_pkt && got_output)) {
893         int len;
894
895         av_init_packet(&out_pkt);
896         len = av_parser_parse2(st->parser,  st->codec,
897                                &out_pkt.data, &out_pkt.size, data, size,
898                                pkt->pts, pkt->dts, pkt->pos);
899
900         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
901         /* increment read pointer */
902         data += len;
903         size -= len;
904
905         got_output = !!out_pkt.size;
906
907         if (!out_pkt.size)
908             continue;
909
910         if (pkt->side_data) {
911             out_pkt.side_data       = pkt->side_data;
912             out_pkt.side_data_elems = pkt->side_data_elems;
913             pkt->side_data       = NULL;
914             pkt->side_data_elems = 0;
915         }
916
917         /* set the duration */
918         out_pkt.duration = 0;
919         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
920             if (st->codec->sample_rate > 0) {
921                 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
922                                                     (AVRational){ 1, st->codec->sample_rate },
923                                                     st->time_base,
924                                                     AV_ROUND_DOWN);
925             }
926         } else if (st->codec->time_base.num != 0 &&
927                    st->codec->time_base.den != 0) {
928             out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
929                                                 st->codec->time_base,
930                                                 st->time_base,
931                                                 AV_ROUND_DOWN);
932         }
933
934         out_pkt.stream_index = st->index;
935         out_pkt.pts = st->parser->pts;
936         out_pkt.dts = st->parser->dts;
937         out_pkt.pos = st->parser->pos;
938
939         if (st->parser->key_frame == 1 ||
940             (st->parser->key_frame == -1 &&
941              st->parser->pict_type == AV_PICTURE_TYPE_I))
942             out_pkt.flags |= AV_PKT_FLAG_KEY;
943
944         compute_pkt_fields(s, st, st->parser, &out_pkt);
945
946         if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
947             out_pkt.flags & AV_PKT_FLAG_KEY) {
948             ff_reduce_index(s, st->index);
949             av_add_index_entry(st, st->parser->frame_offset, out_pkt.dts,
950                                0, 0, AVINDEX_KEYFRAME);
951         }
952
953         if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
954             out_pkt.buf   = pkt->buf;
955             pkt->buf      = NULL;
956 #if FF_API_DESTRUCT_PACKET
957 FF_DISABLE_DEPRECATION_WARNINGS
958             out_pkt.destruct = pkt->destruct;
959             pkt->destruct = NULL;
960 FF_ENABLE_DEPRECATION_WARNINGS
961 #endif
962         }
963         if ((ret = av_dup_packet(&out_pkt)) < 0)
964             goto fail;
965
966         if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
967             av_free_packet(&out_pkt);
968             ret = AVERROR(ENOMEM);
969             goto fail;
970         }
971     }
972
973
974     /* end of the stream => close and free the parser */
975     if (pkt == &flush_pkt) {
976         av_parser_close(st->parser);
977         st->parser = NULL;
978     }
979
980 fail:
981     av_free_packet(pkt);
982     return ret;
983 }
984
985 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
986                                    AVPacketList **pkt_buffer_end,
987                                    AVPacket      *pkt)
988 {
989     AVPacketList *pktl;
990     av_assert0(*pkt_buffer);
991     pktl = *pkt_buffer;
992     *pkt = pktl->pkt;
993     *pkt_buffer = pktl->next;
994     if (!pktl->next)
995         *pkt_buffer_end = NULL;
996     av_freep(&pktl);
997     return 0;
998 }
999
1000 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1001 {
1002     int ret = 0, i, got_packet = 0;
1003
1004     av_init_packet(pkt);
1005
1006     while (!got_packet && !s->parse_queue) {
1007         AVStream *st;
1008         AVPacket cur_pkt;
1009
1010         /* read next packet */
1011         ret = ff_read_packet(s, &cur_pkt);
1012         if (ret < 0) {
1013             if (ret == AVERROR(EAGAIN))
1014                 return ret;
1015             /* flush the parsers */
1016             for(i = 0; i < s->nb_streams; i++) {
1017                 st = s->streams[i];
1018                 if (st->parser && st->need_parsing)
1019                     parse_packet(s, NULL, st->index);
1020             }
1021             /* all remaining packets are now in parse_queue =>
1022              * really terminate parsing */
1023             break;
1024         }
1025         ret = 0;
1026         st  = s->streams[cur_pkt.stream_index];
1027
1028         if (cur_pkt.pts != AV_NOPTS_VALUE &&
1029             cur_pkt.dts != AV_NOPTS_VALUE &&
1030             cur_pkt.pts < cur_pkt.dts) {
1031             av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1032                    cur_pkt.stream_index,
1033                    cur_pkt.pts,
1034                    cur_pkt.dts,
1035                    cur_pkt.size);
1036         }
1037         if (s->debug & FF_FDEBUG_TS)
1038             av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1039                    cur_pkt.stream_index,
1040                    cur_pkt.pts,
1041                    cur_pkt.dts,
1042                    cur_pkt.size,
1043                    cur_pkt.duration,
1044                    cur_pkt.flags);
1045
1046         if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1047             st->parser = av_parser_init(st->codec->codec_id);
1048             if (!st->parser) {
1049                 /* no parser available: just output the raw packets */
1050                 st->need_parsing = AVSTREAM_PARSE_NONE;
1051             } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1052                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1053             } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1054                 st->parser->flags |= PARSER_FLAG_ONCE;
1055             }
1056         }
1057
1058         if (!st->need_parsing || !st->parser) {
1059             /* no parsing needed: we just output the packet as is */
1060             *pkt = cur_pkt;
1061             compute_pkt_fields(s, st, NULL, pkt);
1062             if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1063                 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1064                 ff_reduce_index(s, st->index);
1065                 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1066             }
1067             got_packet = 1;
1068         } else if (st->discard < AVDISCARD_ALL) {
1069             if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1070                 return ret;
1071         } else {
1072             /* free packet */
1073             av_free_packet(&cur_pkt);
1074         }
1075     }
1076
1077     if (!got_packet && s->parse_queue)
1078         ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1079
1080     if(s->debug & FF_FDEBUG_TS)
1081         av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1082             pkt->stream_index,
1083             pkt->pts,
1084             pkt->dts,
1085             pkt->size,
1086             pkt->duration,
1087             pkt->flags);
1088
1089     return ret;
1090 }
1091
1092 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1093 {
1094     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1095     int          eof = 0;
1096
1097     if (!genpts)
1098         return s->packet_buffer ? read_from_packet_buffer(&s->packet_buffer,
1099                                                           &s->packet_buffer_end,
1100                                                           pkt) :
1101                                   read_frame_internal(s, pkt);
1102
1103     for (;;) {
1104         int ret;
1105         AVPacketList *pktl = s->packet_buffer;
1106
1107         if (pktl) {
1108             AVPacket *next_pkt = &pktl->pkt;
1109
1110             if (next_pkt->dts != AV_NOPTS_VALUE) {
1111                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1112                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1113                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1114                         (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0) &&
1115                          av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1116                         next_pkt->pts = pktl->pkt.dts;
1117                     }
1118                     pktl = pktl->next;
1119                 }
1120                 pktl = s->packet_buffer;
1121             }
1122
1123             /* read packet from packet buffer, if there is data */
1124             if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1125                   next_pkt->dts != AV_NOPTS_VALUE && !eof))
1126                 return read_from_packet_buffer(&s->packet_buffer,
1127                                                &s->packet_buffer_end, pkt);
1128         }
1129
1130         ret = read_frame_internal(s, pkt);
1131         if (ret < 0) {
1132             if (pktl && ret != AVERROR(EAGAIN)) {
1133                 eof = 1;
1134                 continue;
1135             } else
1136                 return ret;
1137         }
1138
1139         if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1140                           &s->packet_buffer_end)) < 0)
1141             return AVERROR(ENOMEM);
1142     }
1143 }
1144
1145 /* XXX: suppress the packet queue */
1146 static void flush_packet_queue(AVFormatContext *s)
1147 {
1148     free_packet_buffer(&s->parse_queue,       &s->parse_queue_end);
1149     free_packet_buffer(&s->packet_buffer,     &s->packet_buffer_end);
1150     free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1151
1152     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1153 }
1154
1155 /*******************************************************/
1156 /* seek support */
1157
1158 int av_find_default_stream_index(AVFormatContext *s)
1159 {
1160     int first_audio_index = -1;
1161     int i;
1162     AVStream *st;
1163
1164     if (s->nb_streams <= 0)
1165         return -1;
1166     for(i = 0; i < s->nb_streams; i++) {
1167         st = s->streams[i];
1168         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1169             !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1170             return i;
1171         }
1172         if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1173             first_audio_index = i;
1174     }
1175     return first_audio_index >= 0 ? first_audio_index : 0;
1176 }
1177
1178 /**
1179  * Flush the frame reader.
1180  */
1181 void ff_read_frame_flush(AVFormatContext *s)
1182 {
1183     AVStream *st;
1184     int i, j;
1185
1186     flush_packet_queue(s);
1187
1188     /* for each stream, reset read state */
1189     for(i = 0; i < s->nb_streams; i++) {
1190         st = s->streams[i];
1191
1192         if (st->parser) {
1193             av_parser_close(st->parser);
1194             st->parser = NULL;
1195         }
1196         st->last_IP_pts = AV_NOPTS_VALUE;
1197         st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1198
1199         st->probe_packets = MAX_PROBE_PACKETS;
1200
1201         for(j=0; j<MAX_REORDER_DELAY+1; j++)
1202             st->pts_buffer[j]= AV_NOPTS_VALUE;
1203     }
1204 }
1205
1206 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1207 {
1208     int i;
1209
1210     for(i = 0; i < s->nb_streams; i++) {
1211         AVStream *st = s->streams[i];
1212
1213         st->cur_dts = av_rescale(timestamp,
1214                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1215                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1216     }
1217 }
1218
1219 void ff_reduce_index(AVFormatContext *s, int stream_index)
1220 {
1221     AVStream *st= s->streams[stream_index];
1222     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1223
1224     if((unsigned)st->nb_index_entries >= max_entries){
1225         int i;
1226         for(i=0; 2*i<st->nb_index_entries; i++)
1227             st->index_entries[i]= st->index_entries[2*i];
1228         st->nb_index_entries= i;
1229     }
1230 }
1231
1232 int ff_add_index_entry(AVIndexEntry **index_entries,
1233                        int *nb_index_entries,
1234                        unsigned int *index_entries_allocated_size,
1235                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1236 {
1237     AVIndexEntry *entries, *ie;
1238     int index;
1239
1240     if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1241         return -1;
1242
1243     entries = av_fast_realloc(*index_entries,
1244                               index_entries_allocated_size,
1245                               (*nb_index_entries + 1) *
1246                               sizeof(AVIndexEntry));
1247     if(!entries)
1248         return -1;
1249
1250     *index_entries= entries;
1251
1252     index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1253
1254     if(index<0){
1255         index= (*nb_index_entries)++;
1256         ie= &entries[index];
1257         assert(index==0 || ie[-1].timestamp < timestamp);
1258     }else{
1259         ie= &entries[index];
1260         if(ie->timestamp != timestamp){
1261             if(ie->timestamp <= timestamp)
1262                 return -1;
1263             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1264             (*nb_index_entries)++;
1265         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1266             distance= ie->min_distance;
1267     }
1268
1269     ie->pos = pos;
1270     ie->timestamp = timestamp;
1271     ie->min_distance= distance;
1272     ie->size= size;
1273     ie->flags = flags;
1274
1275     return index;
1276 }
1277
1278 int av_add_index_entry(AVStream *st,
1279                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1280 {
1281     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1282                               &st->index_entries_allocated_size, pos,
1283                               timestamp, size, distance, flags);
1284 }
1285
1286 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1287                               int64_t wanted_timestamp, int flags)
1288 {
1289     int a, b, m;
1290     int64_t timestamp;
1291
1292     a = - 1;
1293     b = nb_entries;
1294
1295     //optimize appending index entries at the end
1296     if(b && entries[b-1].timestamp < wanted_timestamp)
1297         a= b-1;
1298
1299     while (b - a > 1) {
1300         m = (a + b) >> 1;
1301         timestamp = entries[m].timestamp;
1302         if(timestamp >= wanted_timestamp)
1303             b = m;
1304         if(timestamp <= wanted_timestamp)
1305             a = m;
1306     }
1307     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1308
1309     if(!(flags & AVSEEK_FLAG_ANY)){
1310         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1311             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1312         }
1313     }
1314
1315     if(m == nb_entries)
1316         return -1;
1317     return  m;
1318 }
1319
1320 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1321                               int flags)
1322 {
1323     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1324                                      wanted_timestamp, flags);
1325 }
1326
1327 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1328 {
1329     AVInputFormat *avif= s->iformat;
1330     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1331     int64_t ts_min, ts_max, ts;
1332     int index;
1333     int64_t ret;
1334     AVStream *st;
1335
1336     if (stream_index < 0)
1337         return -1;
1338
1339     av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1340
1341     ts_max=
1342     ts_min= AV_NOPTS_VALUE;
1343     pos_limit= -1; //gcc falsely says it may be uninitialized
1344
1345     st= s->streams[stream_index];
1346     if(st->index_entries){
1347         AVIndexEntry *e;
1348
1349         index= av_index_search_timestamp(st, target_ts, flags | AVSEEK_FLAG_BACKWARD); //FIXME whole func must be checked for non-keyframe entries in index case, especially read_timestamp()
1350         index= FFMAX(index, 0);
1351         e= &st->index_entries[index];
1352
1353         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1354             pos_min= e->pos;
1355             ts_min= e->timestamp;
1356             av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1357                     pos_min,ts_min);
1358         }else{
1359             assert(index==0);
1360         }
1361
1362         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1363         assert(index < st->nb_index_entries);
1364         if(index >= 0){
1365             e= &st->index_entries[index];
1366             assert(e->timestamp >= target_ts);
1367             pos_max= e->pos;
1368             ts_max= e->timestamp;
1369             pos_limit= pos_max - e->min_distance;
1370             av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1371                     pos_max,pos_limit, ts_max);
1372         }
1373     }
1374
1375     pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1376     if(pos<0)
1377         return -1;
1378
1379     /* do the seek */
1380     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1381         return ret;
1382
1383     ff_update_cur_dts(s, st, ts);
1384
1385     return 0;
1386 }
1387
1388 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1389                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1390                       int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1391                       int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1392 {
1393     int64_t pos, ts;
1394     int64_t start_pos, filesize;
1395     int no_change;
1396
1397     av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1398
1399     if(ts_min == AV_NOPTS_VALUE){
1400         pos_min = s->data_offset;
1401         ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1402         if (ts_min == AV_NOPTS_VALUE)
1403             return -1;
1404     }
1405
1406     if(ts_max == AV_NOPTS_VALUE){
1407         int step= 1024;
1408         filesize = avio_size(s->pb);
1409         pos_max = filesize - 1;
1410         do{
1411             pos_max -= step;
1412             ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1413             step += step;
1414         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1415         if (ts_max == AV_NOPTS_VALUE)
1416             return -1;
1417
1418         for(;;){
1419             int64_t tmp_pos= pos_max + 1;
1420             int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1421             if(tmp_ts == AV_NOPTS_VALUE)
1422                 break;
1423             ts_max= tmp_ts;
1424             pos_max= tmp_pos;
1425             if(tmp_pos >= filesize)
1426                 break;
1427         }
1428         pos_limit= pos_max;
1429     }
1430
1431     if(ts_min > ts_max){
1432         return -1;
1433     }else if(ts_min == ts_max){
1434         pos_limit= pos_min;
1435     }
1436
1437     no_change=0;
1438     while (pos_min < pos_limit) {
1439         av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1440                 pos_min, pos_max, ts_min, ts_max);
1441         assert(pos_limit <= pos_max);
1442
1443         if(no_change==0){
1444             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1445             // interpolate position (better than dichotomy)
1446             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1447                 + pos_min - approximate_keyframe_distance;
1448         }else if(no_change==1){
1449             // bisection, if interpolation failed to change min or max pos last time
1450             pos = (pos_min + pos_limit)>>1;
1451         }else{
1452             /* linear search if bisection failed, can only happen if there
1453                are very few or no keyframes between min/max */
1454             pos=pos_min;
1455         }
1456         if(pos <= pos_min)
1457             pos= pos_min + 1;
1458         else if(pos > pos_limit)
1459             pos= pos_limit;
1460         start_pos= pos;
1461
1462         ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1463         if(pos == pos_max)
1464             no_change++;
1465         else
1466             no_change=0;
1467         av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1468                 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1469                 pos_limit, start_pos, no_change);
1470         if(ts == AV_NOPTS_VALUE){
1471             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1472             return -1;
1473         }
1474         assert(ts != AV_NOPTS_VALUE);
1475         if (target_ts <= ts) {
1476             pos_limit = start_pos - 1;
1477             pos_max = pos;
1478             ts_max = ts;
1479         }
1480         if (target_ts >= ts) {
1481             pos_min = pos;
1482             ts_min = ts;
1483         }
1484     }
1485
1486     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1487     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1488     pos_min = pos;
1489     ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1490     pos_min++;
1491     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1492     av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1493             pos, ts_min, target_ts, ts_max);
1494     *ts_ret= ts;
1495     return pos;
1496 }
1497
1498 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1499     int64_t pos_min, pos_max;
1500
1501     pos_min = s->data_offset;
1502     pos_max = avio_size(s->pb) - 1;
1503
1504     if     (pos < pos_min) pos= pos_min;
1505     else if(pos > pos_max) pos= pos_max;
1506
1507     avio_seek(s->pb, pos, SEEK_SET);
1508
1509     return 0;
1510 }
1511
1512 static int seek_frame_generic(AVFormatContext *s,
1513                                  int stream_index, int64_t timestamp, int flags)
1514 {
1515     int index;
1516     int64_t ret;
1517     AVStream *st;
1518     AVIndexEntry *ie;
1519
1520     st = s->streams[stream_index];
1521
1522     index = av_index_search_timestamp(st, timestamp, flags);
1523
1524     if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1525         return -1;
1526
1527     if(index < 0 || index==st->nb_index_entries-1){
1528         AVPacket pkt;
1529
1530         if(st->nb_index_entries){
1531             assert(st->index_entries);
1532             ie= &st->index_entries[st->nb_index_entries-1];
1533             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1534                 return ret;
1535             ff_update_cur_dts(s, st, ie->timestamp);
1536         }else{
1537             if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1538                 return ret;
1539         }
1540         for (;;) {
1541             int read_status;
1542             do{
1543                 read_status = av_read_frame(s, &pkt);
1544             } while (read_status == AVERROR(EAGAIN));
1545             if (read_status < 0)
1546                 break;
1547             av_free_packet(&pkt);
1548             if(stream_index == pkt.stream_index){
1549                 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1550                     break;
1551             }
1552         }
1553         index = av_index_search_timestamp(st, timestamp, flags);
1554     }
1555     if (index < 0)
1556         return -1;
1557
1558     ff_read_frame_flush(s);
1559     if (s->iformat->read_seek){
1560         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1561             return 0;
1562     }
1563     ie = &st->index_entries[index];
1564     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1565         return ret;
1566     ff_update_cur_dts(s, st, ie->timestamp);
1567
1568     return 0;
1569 }
1570
1571 static int seek_frame_internal(AVFormatContext *s, int stream_index,
1572                                int64_t timestamp, int flags)
1573 {
1574     int ret;
1575     AVStream *st;
1576
1577     if (flags & AVSEEK_FLAG_BYTE) {
1578         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1579             return -1;
1580         ff_read_frame_flush(s);
1581         return seek_frame_byte(s, stream_index, timestamp, flags);
1582     }
1583
1584     if(stream_index < 0){
1585         stream_index= av_find_default_stream_index(s);
1586         if(stream_index < 0)
1587             return -1;
1588
1589         st= s->streams[stream_index];
1590         /* timestamp for default must be expressed in AV_TIME_BASE units */
1591         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1592     }
1593
1594     /* first, we try the format specific seek */
1595     if (s->iformat->read_seek) {
1596         ff_read_frame_flush(s);
1597         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1598     } else
1599         ret = -1;
1600     if (ret >= 0) {
1601         return 0;
1602     }
1603
1604     if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1605         ff_read_frame_flush(s);
1606         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1607     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1608         ff_read_frame_flush(s);
1609         return seek_frame_generic(s, stream_index, timestamp, flags);
1610     }
1611     else
1612         return -1;
1613 }
1614
1615 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1616 {
1617     int ret = seek_frame_internal(s, stream_index, timestamp, flags);
1618
1619     if (ret >= 0)
1620         ret = queue_attached_pictures(s);
1621
1622     return ret;
1623 }
1624
1625 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1626 {
1627     if(min_ts > ts || max_ts < ts)
1628         return -1;
1629
1630     if (s->iformat->read_seek2) {
1631         int ret;
1632         ff_read_frame_flush(s);
1633         ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1634
1635         if (ret >= 0)
1636             ret = queue_attached_pictures(s);
1637         return ret;
1638     }
1639
1640     if(s->iformat->read_timestamp){
1641         //try to seek via read_timestamp()
1642     }
1643
1644     // Fall back on old API if new is not implemented but old is.
1645     // Note the old API has somewhat different semantics.
1646     if(s->iformat->read_seek || 1)
1647         return av_seek_frame(s, stream_index, ts, flags | ((uint64_t)ts - min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0));
1648
1649     // try some generic seek like seek_frame_generic() but with new ts semantics
1650 }
1651
1652 /*******************************************************/
1653
1654 /**
1655  * Return TRUE if the stream has accurate duration in any stream.
1656  *
1657  * @return TRUE if the stream has accurate duration for at least one component.
1658  */
1659 static int has_duration(AVFormatContext *ic)
1660 {
1661     int i;
1662     AVStream *st;
1663
1664     for(i = 0;i < ic->nb_streams; i++) {
1665         st = ic->streams[i];
1666         if (st->duration != AV_NOPTS_VALUE)
1667             return 1;
1668     }
1669     if (ic->duration != AV_NOPTS_VALUE)
1670         return 1;
1671     return 0;
1672 }
1673
1674 /**
1675  * Estimate the stream timings from the one of each components.
1676  *
1677  * Also computes the global bitrate if possible.
1678  */
1679 static void update_stream_timings(AVFormatContext *ic)
1680 {
1681     int64_t start_time, start_time1, end_time, end_time1;
1682     int64_t duration, duration1, filesize;
1683     int i;
1684     AVStream *st;
1685
1686     start_time = INT64_MAX;
1687     end_time = INT64_MIN;
1688     duration = INT64_MIN;
1689     for(i = 0;i < ic->nb_streams; i++) {
1690         st = ic->streams[i];
1691         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1692             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1693             start_time = FFMIN(start_time, start_time1);
1694             if (st->duration != AV_NOPTS_VALUE) {
1695                 end_time1 = start_time1
1696                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1697                 end_time = FFMAX(end_time, end_time1);
1698             }
1699         }
1700         if (st->duration != AV_NOPTS_VALUE) {
1701             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1702             duration = FFMAX(duration, duration1);
1703         }
1704     }
1705     if (start_time != INT64_MAX) {
1706         ic->start_time = start_time;
1707         if (end_time != INT64_MIN)
1708             duration = FFMAX(duration, end_time - start_time);
1709     }
1710     if (duration != INT64_MIN) {
1711         ic->duration = duration;
1712         if (ic->pb && (filesize = avio_size(ic->pb)) > 0) {
1713             /* compute the bitrate */
1714             ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
1715                 (double)ic->duration;
1716         }
1717     }
1718 }
1719
1720 static void fill_all_stream_timings(AVFormatContext *ic)
1721 {
1722     int i;
1723     AVStream *st;
1724
1725     update_stream_timings(ic);
1726     for(i = 0;i < ic->nb_streams; i++) {
1727         st = ic->streams[i];
1728         if (st->start_time == AV_NOPTS_VALUE) {
1729             if(ic->start_time != AV_NOPTS_VALUE)
1730                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1731             if(ic->duration != AV_NOPTS_VALUE)
1732                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1733         }
1734     }
1735 }
1736
1737 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1738 {
1739     int64_t filesize, duration;
1740     int i;
1741     AVStream *st;
1742
1743     /* if bit_rate is already set, we believe it */
1744     if (ic->bit_rate <= 0) {
1745         int bit_rate = 0;
1746         for(i=0;i<ic->nb_streams;i++) {
1747             st = ic->streams[i];
1748             if (st->codec->bit_rate > 0) {
1749                 if (INT_MAX - st->codec->bit_rate < bit_rate) {
1750                     bit_rate = 0;
1751                     break;
1752                 }
1753                 bit_rate += st->codec->bit_rate;
1754             }
1755         }
1756         ic->bit_rate = bit_rate;
1757     }
1758
1759     /* if duration is already set, we believe it */
1760     if (ic->duration == AV_NOPTS_VALUE &&
1761         ic->bit_rate != 0) {
1762         filesize = ic->pb ? avio_size(ic->pb) : 0;
1763         if (filesize > 0) {
1764             for(i = 0; i < ic->nb_streams; i++) {
1765                 st = ic->streams[i];
1766                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1767                 if (st->duration == AV_NOPTS_VALUE)
1768                     st->duration = duration;
1769             }
1770         }
1771     }
1772 }
1773
1774 #define DURATION_MAX_READ_SIZE 250000
1775 #define DURATION_MAX_RETRY 3
1776
1777 /* only usable for MPEG-PS streams */
1778 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1779 {
1780     AVPacket pkt1, *pkt = &pkt1;
1781     AVStream *st;
1782     int read_size, i, ret;
1783     int64_t end_time;
1784     int64_t filesize, offset, duration;
1785     int retry=0;
1786
1787     /* flush packet queue */
1788     flush_packet_queue(ic);
1789
1790     for (i=0; i<ic->nb_streams; i++) {
1791         st = ic->streams[i];
1792         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1793             av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
1794
1795         if (st->parser) {
1796             av_parser_close(st->parser);
1797             st->parser= NULL;
1798         }
1799     }
1800
1801     /* estimate the end time (duration) */
1802     /* XXX: may need to support wrapping */
1803     filesize = ic->pb ? avio_size(ic->pb) : 0;
1804     end_time = AV_NOPTS_VALUE;
1805     do{
1806         offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1807         if (offset < 0)
1808             offset = 0;
1809
1810         avio_seek(ic->pb, offset, SEEK_SET);
1811         read_size = 0;
1812         for(;;) {
1813             if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1814                 break;
1815
1816             do {
1817                 ret = ff_read_packet(ic, pkt);
1818             } while(ret == AVERROR(EAGAIN));
1819             if (ret != 0)
1820                 break;
1821             read_size += pkt->size;
1822             st = ic->streams[pkt->stream_index];
1823             if (pkt->pts != AV_NOPTS_VALUE &&
1824                 (st->start_time != AV_NOPTS_VALUE ||
1825                  st->first_dts  != AV_NOPTS_VALUE)) {
1826                 duration = end_time = pkt->pts;
1827                 if (st->start_time != AV_NOPTS_VALUE)
1828                     duration -= st->start_time;
1829                 else
1830                     duration -= st->first_dts;
1831                 if (duration < 0)
1832                     duration += 1LL<<st->pts_wrap_bits;
1833                 if (duration > 0) {
1834                     if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
1835                         st->duration = duration;
1836                 }
1837             }
1838             av_free_packet(pkt);
1839         }
1840     }while(   end_time==AV_NOPTS_VALUE
1841            && filesize > (DURATION_MAX_READ_SIZE<<retry)
1842            && ++retry <= DURATION_MAX_RETRY);
1843
1844     fill_all_stream_timings(ic);
1845
1846     avio_seek(ic->pb, old_offset, SEEK_SET);
1847     for (i=0; i<ic->nb_streams; i++) {
1848         st= ic->streams[i];
1849         st->cur_dts= st->first_dts;
1850         st->last_IP_pts = AV_NOPTS_VALUE;
1851     }
1852 }
1853
1854 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
1855 {
1856     int64_t file_size;
1857
1858     /* get the file size, if possible */
1859     if (ic->iformat->flags & AVFMT_NOFILE) {
1860         file_size = 0;
1861     } else {
1862         file_size = avio_size(ic->pb);
1863         file_size = FFMAX(0, file_size);
1864     }
1865
1866     if ((!strcmp(ic->iformat->name, "mpeg") ||
1867          !strcmp(ic->iformat->name, "mpegts")) &&
1868         file_size && ic->pb->seekable) {
1869         /* get accurate estimate from the PTSes */
1870         estimate_timings_from_pts(ic, old_offset);
1871     } else if (has_duration(ic)) {
1872         /* at least one component has timings - we use them for all
1873            the components */
1874         fill_all_stream_timings(ic);
1875     } else {
1876         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1877         /* less precise: use bitrate info */
1878         estimate_timings_from_bit_rate(ic);
1879     }
1880     update_stream_timings(ic);
1881
1882     {
1883         int i;
1884         AVStream av_unused *st;
1885         for(i = 0;i < ic->nb_streams; i++) {
1886             st = ic->streams[i];
1887             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
1888                     (double) st->start_time / AV_TIME_BASE,
1889                     (double) st->duration   / AV_TIME_BASE);
1890         }
1891         av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1892                 (double) ic->start_time / AV_TIME_BASE,
1893                 (double) ic->duration   / AV_TIME_BASE,
1894                 ic->bit_rate / 1000);
1895     }
1896 }
1897
1898 static int has_codec_parameters(AVStream *st)
1899 {
1900     AVCodecContext *avctx = st->codec;
1901     int val;
1902     switch (avctx->codec_type) {
1903     case AVMEDIA_TYPE_AUDIO:
1904         val = avctx->sample_rate && avctx->channels;
1905         if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
1906             return 0;
1907         break;
1908     case AVMEDIA_TYPE_VIDEO:
1909         val = avctx->width;
1910         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
1911             return 0;
1912         break;
1913     default:
1914         val = 1;
1915         break;
1916     }
1917     return avctx->codec_id != AV_CODEC_ID_NONE && val != 0;
1918 }
1919
1920 static int has_decode_delay_been_guessed(AVStream *st)
1921 {
1922     return st->codec->codec_id != AV_CODEC_ID_H264 ||
1923         st->info->nb_decoded_frames >= 6;
1924 }
1925
1926 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
1927 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
1928 {
1929     const AVCodec *codec;
1930     int got_picture = 1, ret = 0;
1931     AVFrame *frame = av_frame_alloc();
1932     AVPacket pkt = *avpkt;
1933
1934     if (!frame)
1935         return AVERROR(ENOMEM);
1936
1937     if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
1938         AVDictionary *thread_opt = NULL;
1939
1940         codec = st->codec->codec ? st->codec->codec :
1941                                    avcodec_find_decoder(st->codec->codec_id);
1942
1943         if (!codec) {
1944             st->info->found_decoder = -1;
1945             ret = -1;
1946             goto fail;
1947         }
1948
1949         /* force thread count to 1 since the h264 decoder will not extract SPS
1950          *  and PPS to extradata during multi-threaded decoding */
1951         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
1952         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
1953         if (!options)
1954             av_dict_free(&thread_opt);
1955         if (ret < 0) {
1956             st->info->found_decoder = -1;
1957             goto fail;
1958         }
1959         st->info->found_decoder = 1;
1960     } else if (!st->info->found_decoder)
1961         st->info->found_decoder = 1;
1962
1963     if (st->info->found_decoder < 0) {
1964         ret = -1;
1965         goto fail;
1966     }
1967
1968     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
1969            ret >= 0 &&
1970            (!has_codec_parameters(st)         ||
1971            !has_decode_delay_been_guessed(st) ||
1972            (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
1973         got_picture = 0;
1974         avcodec_get_frame_defaults(frame);
1975         switch(st->codec->codec_type) {
1976         case AVMEDIA_TYPE_VIDEO:
1977             ret = avcodec_decode_video2(st->codec, frame,
1978                                         &got_picture, &pkt);
1979             break;
1980         case AVMEDIA_TYPE_AUDIO:
1981             ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
1982             break;
1983         default:
1984             break;
1985         }
1986         if (ret >= 0) {
1987             if (got_picture)
1988                 st->info->nb_decoded_frames++;
1989             pkt.data += ret;
1990             pkt.size -= ret;
1991             ret       = got_picture;
1992         }
1993     }
1994
1995 fail:
1996     avcodec_free_frame(&frame);
1997     return ret;
1998 }
1999
2000 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2001 {
2002     while (tags->id != AV_CODEC_ID_NONE) {
2003         if (tags->id == id)
2004             return tags->tag;
2005         tags++;
2006     }
2007     return 0;
2008 }
2009
2010 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2011 {
2012     int i;
2013     for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2014         if(tag == tags[i].tag)
2015             return tags[i].id;
2016     }
2017     for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2018         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2019             return tags[i].id;
2020     }
2021     return AV_CODEC_ID_NONE;
2022 }
2023
2024 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2025 {
2026     if (flt) {
2027         switch (bps) {
2028         case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2029         case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2030         default: return AV_CODEC_ID_NONE;
2031         }
2032     } else {
2033         bps >>= 3;
2034         if (sflags & (1 << (bps - 1))) {
2035             switch (bps) {
2036             case 1:  return AV_CODEC_ID_PCM_S8;
2037             case 2:  return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2038             case 3:  return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2039             case 4:  return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2040             default: return AV_CODEC_ID_NONE;
2041             }
2042         } else {
2043             switch (bps) {
2044             case 1:  return AV_CODEC_ID_PCM_U8;
2045             case 2:  return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2046             case 3:  return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2047             case 4:  return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2048             default: return AV_CODEC_ID_NONE;
2049             }
2050         }
2051     }
2052 }
2053
2054 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2055 {
2056     int i;
2057     for(i=0; tags && tags[i]; i++){
2058         int tag= ff_codec_get_tag(tags[i], id);
2059         if(tag) return tag;
2060     }
2061     return 0;
2062 }
2063
2064 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2065 {
2066     int i;
2067     for(i=0; tags && tags[i]; i++){
2068         enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2069         if(id!=AV_CODEC_ID_NONE) return id;
2070     }
2071     return AV_CODEC_ID_NONE;
2072 }
2073
2074 static void compute_chapters_end(AVFormatContext *s)
2075 {
2076     unsigned int i, j;
2077     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2078
2079     for (i = 0; i < s->nb_chapters; i++)
2080         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2081             AVChapter *ch = s->chapters[i];
2082             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2083                                      : INT64_MAX;
2084
2085             for (j = 0; j < s->nb_chapters; j++) {
2086                 AVChapter *ch1 = s->chapters[j];
2087                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2088                 if (j != i && next_start > ch->start && next_start < end)
2089                     end = next_start;
2090             }
2091             ch->end = (end == INT64_MAX) ? ch->start : end;
2092         }
2093 }
2094
2095 static int get_std_framerate(int i){
2096     if(i<60*12) return i*1001;
2097     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2098 }
2099
2100 /*
2101  * Is the time base unreliable.
2102  * This is a heuristic to balance between quick acceptance of the values in
2103  * the headers vs. some extra checks.
2104  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2105  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2106  * And there are "variable" fps files this needs to detect as well.
2107  */
2108 static int tb_unreliable(AVCodecContext *c){
2109     if(   c->time_base.den >= 101L*c->time_base.num
2110        || c->time_base.den <    5L*c->time_base.num
2111 /*       || c->codec_tag == AV_RL32("DIVX")
2112        || c->codec_tag == AV_RL32("XVID")*/
2113        || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2114        || c->codec_id == AV_CODEC_ID_H264
2115        )
2116         return 1;
2117     return 0;
2118 }
2119
2120 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2121 {
2122     int i, count, ret, read_size, j;
2123     AVStream *st;
2124     AVPacket pkt1, *pkt;
2125     int64_t old_offset = avio_tell(ic->pb);
2126     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2127
2128     for(i=0;i<ic->nb_streams;i++) {
2129         const AVCodec *codec;
2130         AVDictionary *thread_opt = NULL;
2131         st = ic->streams[i];
2132
2133         //only for the split stuff
2134         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2135             st->parser = av_parser_init(st->codec->codec_id);
2136             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2137                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2138             }
2139         }
2140         codec = st->codec->codec ? st->codec->codec :
2141                                    avcodec_find_decoder(st->codec->codec_id);
2142
2143         /* force thread count to 1 since the h264 decoder will not extract SPS
2144          *  and PPS to extradata during multi-threaded decoding */
2145         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2146
2147         /* Ensure that subtitle_header is properly set. */
2148         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2149             && codec && !st->codec->codec)
2150             avcodec_open2(st->codec, codec, options ? &options[i]
2151                               : &thread_opt);
2152
2153         //try to just open decoders, in case this is enough to get parameters
2154         if (!has_codec_parameters(st)) {
2155             if (codec && !st->codec->codec)
2156                 avcodec_open2(st->codec, codec, options ? &options[i]
2157                               : &thread_opt);
2158         }
2159         if (!options)
2160             av_dict_free(&thread_opt);
2161     }
2162
2163     for (i=0; i<ic->nb_streams; i++) {
2164         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2165         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
2166     }
2167
2168     count = 0;
2169     read_size = 0;
2170     for(;;) {
2171         if (ff_check_interrupt(&ic->interrupt_callback)){
2172             ret= AVERROR_EXIT;
2173             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2174             break;
2175         }
2176
2177         /* check if one codec still needs to be handled */
2178         for(i=0;i<ic->nb_streams;i++) {
2179             int fps_analyze_framecount = 20;
2180
2181             st = ic->streams[i];
2182             if (!has_codec_parameters(st))
2183                 break;
2184             /* if the timebase is coarse (like the usual millisecond precision
2185                of mkv), we need to analyze more frames to reliably arrive at
2186                the correct fps */
2187             if (av_q2d(st->time_base) > 0.0005)
2188                 fps_analyze_framecount *= 2;
2189             if (ic->fps_probe_size >= 0)
2190                 fps_analyze_framecount = ic->fps_probe_size;
2191             /* variable fps and no guess at the real fps */
2192             if(   tb_unreliable(st->codec) && !st->avg_frame_rate.num
2193                && st->codec_info_nb_frames < fps_analyze_framecount
2194                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2195                 break;
2196             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2197                 break;
2198             if (st->first_dts == AV_NOPTS_VALUE &&
2199                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2200                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2201                 break;
2202         }
2203         if (i == ic->nb_streams) {
2204             /* NOTE: if the format has no header, then we need to read
2205                some packets to get most of the streams, so we cannot
2206                stop here */
2207             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2208                 /* if we found the info for all the codecs, we can stop */
2209                 ret = count;
2210                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2211                 break;
2212             }
2213         }
2214         /* we did not get all the codec info, but we read too much data */
2215         if (read_size >= ic->probesize) {
2216             ret = count;
2217             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2218             break;
2219         }
2220
2221         /* NOTE: a new stream can be added there if no header in file
2222            (AVFMTCTX_NOHEADER) */
2223         ret = read_frame_internal(ic, &pkt1);
2224         if (ret == AVERROR(EAGAIN))
2225             continue;
2226
2227         if (ret < 0) {
2228             /* EOF or error*/
2229             AVPacket empty_pkt = { 0 };
2230             int err = 0;
2231             av_init_packet(&empty_pkt);
2232
2233             ret = -1; /* we could not have all the codec parameters before EOF */
2234             for(i=0;i<ic->nb_streams;i++) {
2235                 st = ic->streams[i];
2236
2237                 /* flush the decoders */
2238                 if (st->info->found_decoder == 1) {
2239                     do {
2240                         err = try_decode_frame(st, &empty_pkt,
2241                                                (options && i < orig_nb_streams) ?
2242                                                &options[i] : NULL);
2243                     } while (err > 0 && !has_codec_parameters(st));
2244                 }
2245
2246                 if (err < 0) {
2247                     av_log(ic, AV_LOG_WARNING,
2248                            "decoding for stream %d failed\n", st->index);
2249                 } else if (!has_codec_parameters(st)) {
2250                     char buf[256];
2251                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2252                     av_log(ic, AV_LOG_WARNING,
2253                            "Could not find codec parameters (%s)\n", buf);
2254                 } else {
2255                     ret = 0;
2256                 }
2257             }
2258             break;
2259         }
2260
2261         if (ic->flags & AVFMT_FLAG_NOBUFFER) {
2262             pkt = &pkt1;
2263         } else {
2264             pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2265                                 &ic->packet_buffer_end);
2266             if ((ret = av_dup_packet(pkt)) < 0)
2267                 goto find_stream_info_err;
2268         }
2269
2270         read_size += pkt->size;
2271
2272         st = ic->streams[pkt->stream_index];
2273         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2274             /* check for non-increasing dts */
2275             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2276                 st->info->fps_last_dts >= pkt->dts) {
2277                 av_log(ic, AV_LOG_WARNING, "Non-increasing DTS in stream %d: "
2278                        "packet %d with DTS %"PRId64", packet %d with DTS "
2279                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2280                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2281                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2282             }
2283             /* check for a discontinuity in dts - if the difference in dts
2284              * is more than 1000 times the average packet duration in the sequence,
2285              * we treat it as a discontinuity */
2286             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2287                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2288                 (pkt->dts - st->info->fps_last_dts) / 1000 >
2289                 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2290                 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2291                        "packet %d with DTS %"PRId64", packet %d with DTS "
2292                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2293                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2294                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2295             }
2296
2297             /* update stored dts values */
2298             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2299                 st->info->fps_first_dts     = pkt->dts;
2300                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2301             }
2302             st->info->fps_last_dts = pkt->dts;
2303             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2304
2305             /* check max_analyze_duration */
2306             if (av_rescale_q(pkt->dts - st->info->fps_first_dts, st->time_base,
2307                              AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2308                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2309                 break;
2310             }
2311         }
2312         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2313             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2314             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2315                 st->codec->extradata_size= i;
2316                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2317                 if (!st->codec->extradata)
2318                     return AVERROR(ENOMEM);
2319                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2320                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2321             }
2322         }
2323
2324         /* if still no information, we try to open the codec and to
2325            decompress the frame. We try to avoid that in most cases as
2326            it takes longer and uses more memory. For MPEG-4, we need to
2327            decompress for QuickTime.
2328
2329            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2330            least one frame of codec data, this makes sure the codec initializes
2331            the channel configuration and does not only trust the values from the container.
2332         */
2333         try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2334
2335         st->codec_info_nb_frames++;
2336         count++;
2337     }
2338
2339     // close codecs which were opened in try_decode_frame()
2340     for(i=0;i<ic->nb_streams;i++) {
2341         st = ic->streams[i];
2342         avcodec_close(st->codec);
2343     }
2344     for(i=0;i<ic->nb_streams;i++) {
2345         st = ic->streams[i];
2346         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2347             /* estimate average framerate if not set by demuxer */
2348             if (!st->avg_frame_rate.num && st->info->fps_last_dts != st->info->fps_first_dts) {
2349                 int64_t delta_dts = st->info->fps_last_dts - st->info->fps_first_dts;
2350                 int delta_packets = st->info->fps_last_dts_idx - st->info->fps_first_dts_idx;
2351                 int      best_fps = 0;
2352                 double best_error = 0.01;
2353
2354                 if (delta_dts     >= INT64_MAX / st->time_base.num ||
2355                     delta_packets >= INT64_MAX / st->time_base.den ||
2356                     delta_dts < 0)
2357                     continue;
2358                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2359                           delta_packets*(int64_t)st->time_base.den,
2360                           delta_dts*(int64_t)st->time_base.num, 60000);
2361
2362                 /* round guessed framerate to a "standard" framerate if it's
2363                  * within 1% of the original estimate*/
2364                 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
2365                     AVRational std_fps = { get_std_framerate(j), 12*1001 };
2366                     double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
2367
2368                     if (error < best_error) {
2369                         best_error = error;
2370                         best_fps   = std_fps.num;
2371                     }
2372                 }
2373                 if (best_fps) {
2374                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2375                               best_fps, 12*1001, INT_MAX);
2376                 }
2377             }
2378         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2379             if(!st->codec->bits_per_coded_sample)
2380                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2381             // set stream disposition based on audio service type
2382             switch (st->codec->audio_service_type) {
2383             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2384                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2385             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2386                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2387             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2388                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2389             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2390                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2391             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2392                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2393             }
2394         }
2395     }
2396
2397     estimate_timings(ic, old_offset);
2398
2399     compute_chapters_end(ic);
2400
2401  find_stream_info_err:
2402     for (i=0; i < ic->nb_streams; i++) {
2403         if (ic->streams[i]->codec)
2404             ic->streams[i]->codec->thread_count = 0;
2405         av_freep(&ic->streams[i]->info);
2406     }
2407     return ret;
2408 }
2409
2410 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2411 {
2412     int i, j;
2413
2414     for (i = 0; i < ic->nb_programs; i++)
2415         for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2416             if (ic->programs[i]->stream_index[j] == s)
2417                 return ic->programs[i];
2418     return NULL;
2419 }
2420
2421 int av_find_best_stream(AVFormatContext *ic,
2422                         enum AVMediaType type,
2423                         int wanted_stream_nb,
2424                         int related_stream,
2425                         AVCodec **decoder_ret,
2426                         int flags)
2427 {
2428     int i, nb_streams = ic->nb_streams;
2429     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2430     unsigned *program = NULL;
2431     AVCodec *decoder = NULL, *best_decoder = NULL;
2432
2433     if (related_stream >= 0 && wanted_stream_nb < 0) {
2434         AVProgram *p = find_program_from_stream(ic, related_stream);
2435         if (p) {
2436             program = p->stream_index;
2437             nb_streams = p->nb_stream_indexes;
2438         }
2439     }
2440     for (i = 0; i < nb_streams; i++) {
2441         int real_stream_index = program ? program[i] : i;
2442         AVStream *st = ic->streams[real_stream_index];
2443         AVCodecContext *avctx = st->codec;
2444         if (avctx->codec_type != type)
2445             continue;
2446         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2447             continue;
2448         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2449             continue;
2450         if (decoder_ret) {
2451             decoder = avcodec_find_decoder(st->codec->codec_id);
2452             if (!decoder) {
2453                 if (ret < 0)
2454                     ret = AVERROR_DECODER_NOT_FOUND;
2455                 continue;
2456             }
2457         }
2458         if (best_count >= st->codec_info_nb_frames)
2459             continue;
2460         best_count = st->codec_info_nb_frames;
2461         ret = real_stream_index;
2462         best_decoder = decoder;
2463         if (program && i == nb_streams - 1 && ret < 0) {
2464             program = NULL;
2465             nb_streams = ic->nb_streams;
2466             i = 0; /* no related stream found, try again with everything */
2467         }
2468     }
2469     if (decoder_ret)
2470         *decoder_ret = best_decoder;
2471     return ret;
2472 }
2473
2474 /*******************************************************/
2475
2476 int av_read_play(AVFormatContext *s)
2477 {
2478     if (s->iformat->read_play)
2479         return s->iformat->read_play(s);
2480     if (s->pb)
2481         return avio_pause(s->pb, 0);
2482     return AVERROR(ENOSYS);
2483 }
2484
2485 int av_read_pause(AVFormatContext *s)
2486 {
2487     if (s->iformat->read_pause)
2488         return s->iformat->read_pause(s);
2489     if (s->pb)
2490         return avio_pause(s->pb, 1);
2491     return AVERROR(ENOSYS);
2492 }
2493
2494 void avformat_free_context(AVFormatContext *s)
2495 {
2496     int i;
2497     AVStream *st;
2498
2499     av_opt_free(s);
2500     if (s->iformat && s->iformat->priv_class && s->priv_data)
2501         av_opt_free(s->priv_data);
2502
2503     for(i=0;i<s->nb_streams;i++) {
2504         /* free all data in a stream component */
2505         st = s->streams[i];
2506         if (st->parser) {
2507             av_parser_close(st->parser);
2508         }
2509         if (st->attached_pic.data)
2510             av_free_packet(&st->attached_pic);
2511         av_dict_free(&st->metadata);
2512         av_freep(&st->probe_data.buf);
2513         av_free(st->index_entries);
2514         av_free(st->codec->extradata);
2515         av_free(st->codec->subtitle_header);
2516         av_free(st->codec);
2517         av_free(st->priv_data);
2518         av_free(st->info);
2519         av_free(st);
2520     }
2521     for(i=s->nb_programs-1; i>=0; i--) {
2522         av_dict_free(&s->programs[i]->metadata);
2523         av_freep(&s->programs[i]->stream_index);
2524         av_freep(&s->programs[i]);
2525     }
2526     av_freep(&s->programs);
2527     av_freep(&s->priv_data);
2528     while(s->nb_chapters--) {
2529         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2530         av_free(s->chapters[s->nb_chapters]);
2531     }
2532     av_freep(&s->chapters);
2533     av_dict_free(&s->metadata);
2534     av_freep(&s->streams);
2535     av_free(s);
2536 }
2537
2538 void avformat_close_input(AVFormatContext **ps)
2539 {
2540     AVFormatContext *s = *ps;
2541     AVIOContext *pb = s->pb;
2542
2543     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
2544         (s->flags & AVFMT_FLAG_CUSTOM_IO))
2545         pb = NULL;
2546
2547     flush_packet_queue(s);
2548
2549     if (s->iformat) {
2550         if (s->iformat->read_close)
2551             s->iformat->read_close(s);
2552     }
2553
2554     avformat_free_context(s);
2555
2556     *ps = NULL;
2557
2558     avio_close(pb);
2559 }
2560
2561 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2562 {
2563     AVStream *st;
2564     int i;
2565
2566     if (av_reallocp_array(&s->streams, s->nb_streams + 1, sizeof(*s->streams)) < 0) {
2567         s->nb_streams = 0;
2568         return NULL;
2569     }
2570
2571     st = av_mallocz(sizeof(AVStream));
2572     if (!st)
2573         return NULL;
2574     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2575         av_free(st);
2576         return NULL;
2577     }
2578
2579     st->codec = avcodec_alloc_context3(c);
2580     if (s->iformat) {
2581         /* no default bitrate if decoding */
2582         st->codec->bit_rate = 0;
2583     }
2584     st->index = s->nb_streams;
2585     st->start_time = AV_NOPTS_VALUE;
2586     st->duration = AV_NOPTS_VALUE;
2587         /* we set the current DTS to 0 so that formats without any timestamps
2588            but durations get some timestamps, formats with some unknown
2589            timestamps have their first few packets buffered and the
2590            timestamps corrected before they are returned to the user */
2591     st->cur_dts = 0;
2592     st->first_dts = AV_NOPTS_VALUE;
2593     st->probe_packets = MAX_PROBE_PACKETS;
2594
2595     /* default pts setting is MPEG-like */
2596     avpriv_set_pts_info(st, 33, 1, 90000);
2597     st->last_IP_pts = AV_NOPTS_VALUE;
2598     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2599         st->pts_buffer[i]= AV_NOPTS_VALUE;
2600
2601     st->sample_aspect_ratio = (AVRational){0,1};
2602
2603     st->info->fps_first_dts = AV_NOPTS_VALUE;
2604     st->info->fps_last_dts  = AV_NOPTS_VALUE;
2605
2606     s->streams[s->nb_streams++] = st;
2607     return st;
2608 }
2609
2610 AVProgram *av_new_program(AVFormatContext *ac, int id)
2611 {
2612     AVProgram *program=NULL;
2613     int i;
2614
2615     av_dlog(ac, "new_program: id=0x%04x\n", id);
2616
2617     for(i=0; i<ac->nb_programs; i++)
2618         if(ac->programs[i]->id == id)
2619             program = ac->programs[i];
2620
2621     if(!program){
2622         program = av_mallocz(sizeof(AVProgram));
2623         if (!program)
2624             return NULL;
2625         dynarray_add(&ac->programs, &ac->nb_programs, program);
2626         program->discard = AVDISCARD_NONE;
2627     }
2628     program->id = id;
2629
2630     return program;
2631 }
2632
2633 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2634 {
2635     AVChapter *chapter = NULL;
2636     int i;
2637
2638     for(i=0; i<s->nb_chapters; i++)
2639         if(s->chapters[i]->id == id)
2640             chapter = s->chapters[i];
2641
2642     if(!chapter){
2643         chapter= av_mallocz(sizeof(AVChapter));
2644         if(!chapter)
2645             return NULL;
2646         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2647     }
2648     av_dict_set(&chapter->metadata, "title", title, 0);
2649     chapter->id    = id;
2650     chapter->time_base= time_base;
2651     chapter->start = start;
2652     chapter->end   = end;
2653
2654     return chapter;
2655 }
2656
2657 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2658 {
2659     int i, j;
2660     AVProgram *program=NULL;
2661
2662     if (idx >= ac->nb_streams) {
2663         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2664         return;
2665     }
2666
2667     for(i=0; i<ac->nb_programs; i++){
2668         if(ac->programs[i]->id != progid)
2669             continue;
2670         program = ac->programs[i];
2671         for(j=0; j<program->nb_stream_indexes; j++)
2672             if(program->stream_index[j] == idx)
2673                 return;
2674
2675         if (av_reallocp_array(&program->stream_index,
2676                               program->nb_stream_indexes + 1,
2677                               sizeof(*program->stream_index)) < 0) {
2678             program->nb_stream_indexes = 0;
2679             return;
2680         }
2681         program->stream_index[program->nb_stream_indexes++] = idx;
2682         return;
2683     }
2684 }
2685
2686 static void print_fps(double d, const char *postfix){
2687     uint64_t v= lrintf(d*100);
2688     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2689     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2690     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2691 }
2692
2693 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
2694 {
2695     if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
2696         AVDictionaryEntry *tag=NULL;
2697
2698         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2699         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
2700             if(strcmp("language", tag->key))
2701                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
2702         }
2703     }
2704 }
2705
2706 /* "user interface" functions */
2707 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2708 {
2709     char buf[256];
2710     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2711     AVStream *st = ic->streams[i];
2712     int g = av_gcd(st->time_base.num, st->time_base.den);
2713     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
2714     avcodec_string(buf, sizeof(buf), st->codec, is_output);
2715     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2716     /* the pid is an important information, so we display it */
2717     /* XXX: add a generic system */
2718     if (flags & AVFMT_SHOW_IDS)
2719         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2720     if (lang)
2721         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2722     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
2723     av_log(NULL, AV_LOG_INFO, ": %s", buf);
2724     if (st->sample_aspect_ratio.num && // default
2725         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2726         AVRational display_aspect_ratio;
2727         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2728                   st->codec->width*st->sample_aspect_ratio.num,
2729                   st->codec->height*st->sample_aspect_ratio.den,
2730                   1024*1024);
2731         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2732                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2733                  display_aspect_ratio.num, display_aspect_ratio.den);
2734     }
2735     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
2736         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
2737             print_fps(av_q2d(st->avg_frame_rate), "fps");
2738         if(st->time_base.den && st->time_base.num)
2739             print_fps(1/av_q2d(st->time_base), "tbn");
2740         if(st->codec->time_base.den && st->codec->time_base.num)
2741             print_fps(1/av_q2d(st->codec->time_base), "tbc");
2742     }
2743     if (st->disposition & AV_DISPOSITION_DEFAULT)
2744         av_log(NULL, AV_LOG_INFO, " (default)");
2745     if (st->disposition & AV_DISPOSITION_DUB)
2746         av_log(NULL, AV_LOG_INFO, " (dub)");
2747     if (st->disposition & AV_DISPOSITION_ORIGINAL)
2748         av_log(NULL, AV_LOG_INFO, " (original)");
2749     if (st->disposition & AV_DISPOSITION_COMMENT)
2750         av_log(NULL, AV_LOG_INFO, " (comment)");
2751     if (st->disposition & AV_DISPOSITION_LYRICS)
2752         av_log(NULL, AV_LOG_INFO, " (lyrics)");
2753     if (st->disposition & AV_DISPOSITION_KARAOKE)
2754         av_log(NULL, AV_LOG_INFO, " (karaoke)");
2755     if (st->disposition & AV_DISPOSITION_FORCED)
2756         av_log(NULL, AV_LOG_INFO, " (forced)");
2757     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
2758         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
2759     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
2760         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
2761     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
2762         av_log(NULL, AV_LOG_INFO, " (clean effects)");
2763     av_log(NULL, AV_LOG_INFO, "\n");
2764     dump_metadata(NULL, st->metadata, "    ");
2765 }
2766
2767 void av_dump_format(AVFormatContext *ic,
2768                     int index,
2769                     const char *url,
2770                     int is_output)
2771 {
2772     int i;
2773     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
2774     if (ic->nb_streams && !printed)
2775         return;
2776
2777     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2778             is_output ? "Output" : "Input",
2779             index,
2780             is_output ? ic->oformat->name : ic->iformat->name,
2781             is_output ? "to" : "from", url);
2782     dump_metadata(NULL, ic->metadata, "  ");
2783     if (!is_output) {
2784         av_log(NULL, AV_LOG_INFO, "  Duration: ");
2785         if (ic->duration != AV_NOPTS_VALUE) {
2786             int hours, mins, secs, us;
2787             secs = ic->duration / AV_TIME_BASE;
2788             us = ic->duration % AV_TIME_BASE;
2789             mins = secs / 60;
2790             secs %= 60;
2791             hours = mins / 60;
2792             mins %= 60;
2793             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2794                    (100 * us) / AV_TIME_BASE);
2795         } else {
2796             av_log(NULL, AV_LOG_INFO, "N/A");
2797         }
2798         if (ic->start_time != AV_NOPTS_VALUE) {
2799             int secs, us;
2800             av_log(NULL, AV_LOG_INFO, ", start: ");
2801             secs = ic->start_time / AV_TIME_BASE;
2802             us = abs(ic->start_time % AV_TIME_BASE);
2803             av_log(NULL, AV_LOG_INFO, "%d.%06d",
2804                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2805         }
2806         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2807         if (ic->bit_rate) {
2808             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2809         } else {
2810             av_log(NULL, AV_LOG_INFO, "N/A");
2811         }
2812         av_log(NULL, AV_LOG_INFO, "\n");
2813     }
2814     for (i = 0; i < ic->nb_chapters; i++) {
2815         AVChapter *ch = ic->chapters[i];
2816         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
2817         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
2818         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
2819
2820         dump_metadata(NULL, ch->metadata, "    ");
2821     }
2822     if(ic->nb_programs) {
2823         int j, k, total = 0;
2824         for(j=0; j<ic->nb_programs; j++) {
2825             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
2826                                                   "name", NULL, 0);
2827             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2828                    name ? name->value : "");
2829             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
2830             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
2831                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2832                 printed[ic->programs[j]->stream_index[k]] = 1;
2833             }
2834             total += ic->programs[j]->nb_stream_indexes;
2835         }
2836         if (total < ic->nb_streams)
2837             av_log(NULL, AV_LOG_INFO, "  No Program\n");
2838     }
2839     for(i=0;i<ic->nb_streams;i++)
2840         if (!printed[i])
2841             dump_stream_format(ic, i, index, is_output);
2842
2843     av_free(printed);
2844 }
2845
2846 uint64_t ff_ntp_time(void)
2847 {
2848   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
2849 }
2850
2851 int av_get_frame_filename(char *buf, int buf_size,
2852                           const char *path, int number)
2853 {
2854     const char *p;
2855     char *q, buf1[20], c;
2856     int nd, len, percentd_found;
2857
2858     q = buf;
2859     p = path;
2860     percentd_found = 0;
2861     for(;;) {
2862         c = *p++;
2863         if (c == '\0')
2864             break;
2865         if (c == '%') {
2866             do {
2867                 nd = 0;
2868                 while (av_isdigit(*p)) {
2869                     nd = nd * 10 + *p++ - '0';
2870                 }
2871                 c = *p++;
2872             } while (av_isdigit(c));
2873
2874             switch(c) {
2875             case '%':
2876                 goto addchar;
2877             case 'd':
2878                 if (percentd_found)
2879                     goto fail;
2880                 percentd_found = 1;
2881                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2882                 len = strlen(buf1);
2883                 if ((q - buf + len) > buf_size - 1)
2884                     goto fail;
2885                 memcpy(q, buf1, len);
2886                 q += len;
2887                 break;
2888             default:
2889                 goto fail;
2890             }
2891         } else {
2892         addchar:
2893             if ((q - buf) < buf_size - 1)
2894                 *q++ = c;
2895         }
2896     }
2897     if (!percentd_found)
2898         goto fail;
2899     *q = '\0';
2900     return 0;
2901  fail:
2902     *q = '\0';
2903     return -1;
2904 }
2905
2906 static void hex_dump_internal(void *avcl, FILE *f, int level,
2907                               const uint8_t *buf, int size)
2908 {
2909     int len, i, j, c;
2910 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2911
2912     for(i=0;i<size;i+=16) {
2913         len = size - i;
2914         if (len > 16)
2915             len = 16;
2916         PRINT("%08x ", i);
2917         for(j=0;j<16;j++) {
2918             if (j < len)
2919                 PRINT(" %02x", buf[i+j]);
2920             else
2921                 PRINT("   ");
2922         }
2923         PRINT(" ");
2924         for(j=0;j<len;j++) {
2925             c = buf[i+j];
2926             if (c < ' ' || c > '~')
2927                 c = '.';
2928             PRINT("%c", c);
2929         }
2930         PRINT("\n");
2931     }
2932 #undef PRINT
2933 }
2934
2935 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
2936 {
2937     hex_dump_internal(NULL, f, 0, buf, size);
2938 }
2939
2940 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
2941 {
2942     hex_dump_internal(avcl, NULL, level, buf, size);
2943 }
2944
2945 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
2946 {
2947 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2948     PRINT("stream #%d:\n", pkt->stream_index);
2949     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
2950     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
2951     /* DTS is _always_ valid after av_read_frame() */
2952     PRINT("  dts=");
2953     if (pkt->dts == AV_NOPTS_VALUE)
2954         PRINT("N/A");
2955     else
2956         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
2957     /* PTS may not be known if B-frames are present. */
2958     PRINT("  pts=");
2959     if (pkt->pts == AV_NOPTS_VALUE)
2960         PRINT("N/A");
2961     else
2962         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
2963     PRINT("\n");
2964     PRINT("  size=%d\n", pkt->size);
2965 #undef PRINT
2966     if (dump_payload)
2967         av_hex_dump(f, pkt->data, pkt->size);
2968 }
2969
2970 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
2971 {
2972     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
2973 }
2974
2975 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
2976                       AVStream *st)
2977 {
2978     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
2979 }
2980
2981 void av_url_split(char *proto, int proto_size,
2982                   char *authorization, int authorization_size,
2983                   char *hostname, int hostname_size,
2984                   int *port_ptr,
2985                   char *path, int path_size,
2986                   const char *url)
2987 {
2988     const char *p, *ls, *at, *col, *brk;
2989
2990     if (port_ptr)               *port_ptr = -1;
2991     if (proto_size > 0)         proto[0] = 0;
2992     if (authorization_size > 0) authorization[0] = 0;
2993     if (hostname_size > 0)      hostname[0] = 0;
2994     if (path_size > 0)          path[0] = 0;
2995
2996     /* parse protocol */
2997     if ((p = strchr(url, ':'))) {
2998         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
2999         p++; /* skip ':' */
3000         if (*p == '/') p++;
3001         if (*p == '/') p++;
3002     } else {
3003         /* no protocol means plain filename */
3004         av_strlcpy(path, url, path_size);
3005         return;
3006     }
3007
3008     /* separate path from hostname */
3009     ls = strchr(p, '/');
3010     if(!ls)
3011         ls = strchr(p, '?');
3012     if(ls)
3013         av_strlcpy(path, ls, path_size);
3014     else
3015         ls = &p[strlen(p)]; // XXX
3016
3017     /* the rest is hostname, use that to parse auth/port */
3018     if (ls != p) {
3019         /* authorization (user[:pass]@hostname) */
3020         if ((at = strchr(p, '@')) && at < ls) {
3021             av_strlcpy(authorization, p,
3022                        FFMIN(authorization_size, at + 1 - p));
3023             p = at + 1; /* skip '@' */
3024         }
3025
3026         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3027             /* [host]:port */
3028             av_strlcpy(hostname, p + 1,
3029                        FFMIN(hostname_size, brk - p));
3030             if (brk[1] == ':' && port_ptr)
3031                 *port_ptr = atoi(brk + 2);
3032         } else if ((col = strchr(p, ':')) && col < ls) {
3033             av_strlcpy(hostname, p,
3034                        FFMIN(col + 1 - p, hostname_size));
3035             if (port_ptr) *port_ptr = atoi(col + 1);
3036         } else
3037             av_strlcpy(hostname, p,
3038                        FFMIN(ls + 1 - p, hostname_size));
3039     }
3040 }
3041
3042 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3043 {
3044     int i;
3045     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3046                                            '4', '5', '6', '7',
3047                                            '8', '9', 'A', 'B',
3048                                            'C', 'D', 'E', 'F' };
3049     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3050                                            '4', '5', '6', '7',
3051                                            '8', '9', 'a', 'b',
3052                                            'c', 'd', 'e', 'f' };
3053     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3054
3055     for(i = 0; i < s; i++) {
3056         buff[i * 2]     = hex_table[src[i] >> 4];
3057         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3058     }
3059
3060     return buff;
3061 }
3062
3063 int ff_hex_to_data(uint8_t *data, const char *p)
3064 {
3065     int c, len, v;
3066
3067     len = 0;
3068     v = 1;
3069     for (;;) {
3070         p += strspn(p, SPACE_CHARS);
3071         if (*p == '\0')
3072             break;
3073         c = av_toupper((unsigned char) *p++);
3074         if (c >= '0' && c <= '9')
3075             c = c - '0';
3076         else if (c >= 'A' && c <= 'F')
3077             c = c - 'A' + 10;
3078         else
3079             break;
3080         v = (v << 4) | c;
3081         if (v & 0x100) {
3082             if (data)
3083                 data[len] = v;
3084             len++;
3085             v = 1;
3086         }
3087     }
3088     return len;
3089 }
3090
3091 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3092                          unsigned int pts_num, unsigned int pts_den)
3093 {
3094     AVRational new_tb;
3095     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3096         if(new_tb.num != pts_num)
3097             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3098     }else
3099         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3100
3101     if(new_tb.num <= 0 || new_tb.den <= 0) {
3102         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3103         return;
3104     }
3105     s->time_base = new_tb;
3106     s->pts_wrap_bits = pts_wrap_bits;
3107 }
3108
3109 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3110                         void *context)
3111 {
3112     const char *ptr = str;
3113
3114     /* Parse key=value pairs. */
3115     for (;;) {
3116         const char *key;
3117         char *dest = NULL, *dest_end;
3118         int key_len, dest_len = 0;
3119
3120         /* Skip whitespace and potential commas. */
3121         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3122             ptr++;
3123         if (!*ptr)
3124             break;
3125
3126         key = ptr;
3127
3128         if (!(ptr = strchr(key, '=')))
3129             break;
3130         ptr++;
3131         key_len = ptr - key;
3132
3133         callback_get_buf(context, key, key_len, &dest, &dest_len);
3134         dest_end = dest + dest_len - 1;
3135
3136         if (*ptr == '\"') {
3137             ptr++;
3138             while (*ptr && *ptr != '\"') {
3139                 if (*ptr == '\\') {
3140                     if (!ptr[1])
3141                         break;
3142                     if (dest && dest < dest_end)
3143                         *dest++ = ptr[1];
3144                     ptr += 2;
3145                 } else {
3146                     if (dest && dest < dest_end)
3147                         *dest++ = *ptr;
3148                     ptr++;
3149                 }
3150             }
3151             if (*ptr == '\"')
3152                 ptr++;
3153         } else {
3154             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
3155                 if (dest && dest < dest_end)
3156                     *dest++ = *ptr;
3157         }
3158         if (dest)
3159             *dest = 0;
3160     }
3161 }
3162
3163 int ff_find_stream_index(AVFormatContext *s, int id)
3164 {
3165     int i;
3166     for (i = 0; i < s->nb_streams; i++) {
3167         if (s->streams[i]->id == id)
3168             return i;
3169     }
3170     return -1;
3171 }
3172
3173 int64_t ff_iso8601_to_unix_time(const char *datestr)
3174 {
3175 #if HAVE_STRPTIME
3176     struct tm time1 = {0}, time2 = {0};
3177     char *ret1, *ret2;
3178     ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
3179     ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
3180     if (ret2 && !ret1)
3181         return av_timegm(&time2);
3182     else
3183         return av_timegm(&time1);
3184 #else
3185     av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
3186                                  "the date string.\n");
3187     return 0;
3188 #endif
3189 }
3190
3191 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
3192 {
3193     if (ofmt) {
3194         if (ofmt->query_codec)
3195             return ofmt->query_codec(codec_id, std_compliance);
3196         else if (ofmt->codec_tag)
3197             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
3198         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
3199                  codec_id == ofmt->subtitle_codec)
3200             return 1;
3201     }
3202     return AVERROR_PATCHWELCOME;
3203 }
3204
3205 int avformat_network_init(void)
3206 {
3207 #if CONFIG_NETWORK
3208     int ret;
3209     ff_network_inited_globally = 1;
3210     if ((ret = ff_network_init()) < 0)
3211         return ret;
3212     ff_tls_init();
3213 #endif
3214     return 0;
3215 }
3216
3217 int avformat_network_deinit(void)
3218 {
3219 #if CONFIG_NETWORK
3220     ff_network_close();
3221     ff_tls_deinit();
3222 #endif
3223     return 0;
3224 }
3225
3226 int ff_add_param_change(AVPacket *pkt, int32_t channels,
3227                         uint64_t channel_layout, int32_t sample_rate,
3228                         int32_t width, int32_t height)
3229 {
3230     uint32_t flags = 0;
3231     int size = 4;
3232     uint8_t *data;
3233     if (!pkt)
3234         return AVERROR(EINVAL);
3235     if (channels) {
3236         size += 4;
3237         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
3238     }
3239     if (channel_layout) {
3240         size += 8;
3241         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
3242     }
3243     if (sample_rate) {
3244         size += 4;
3245         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
3246     }
3247     if (width || height) {
3248         size += 8;
3249         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
3250     }
3251     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
3252     if (!data)
3253         return AVERROR(ENOMEM);
3254     bytestream_put_le32(&data, flags);
3255     if (channels)
3256         bytestream_put_le32(&data, channels);
3257     if (channel_layout)
3258         bytestream_put_le64(&data, channel_layout);
3259     if (sample_rate)
3260         bytestream_put_le32(&data, sample_rate);
3261     if (width || height) {
3262         bytestream_put_le32(&data, width);
3263         bytestream_put_le32(&data, height);
3264     }
3265     return 0;
3266 }
3267
3268 int ff_generate_avci_extradata(AVStream *st)
3269 {
3270     static const uint8_t avci100_1080p_extradata[] = {
3271         // SPS
3272         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
3273         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
3274         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
3275         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
3276         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
3277         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
3278         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
3279         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
3280         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3281         // PPS
3282         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
3283         0xd0
3284     };
3285     static const uint8_t avci100_1080i_extradata[] = {
3286         // SPS
3287         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
3288         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
3289         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
3290         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
3291         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
3292         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
3293         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
3294         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
3295         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
3296         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
3297         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
3298         // PPS
3299         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
3300         0xd0
3301     };
3302     static const uint8_t avci50_1080i_extradata[] = {
3303         // SPS
3304         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
3305         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
3306         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
3307         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
3308         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
3309         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
3310         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
3311         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
3312         0x81, 0x13, 0xf7, 0xff, 0x80, 0x01, 0x80, 0x02,
3313         0x71, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
3314         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
3315         // PPS
3316         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
3317         0x11
3318     };
3319     static const uint8_t avci100_720p_extradata[] = {
3320         // SPS
3321         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
3322         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
3323         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
3324         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
3325         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
3326         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
3327         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
3328         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
3329         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
3330         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
3331         // PPS
3332         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
3333         0x11
3334     };
3335
3336     const uint8_t *data = NULL;
3337     int size = 0;
3338
3339     if (st->codec->width == 1920) {
3340         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
3341             data = avci100_1080p_extradata;
3342             size = sizeof(avci100_1080p_extradata);
3343         } else {
3344             data = avci100_1080i_extradata;
3345             size = sizeof(avci100_1080i_extradata);
3346         }
3347     } else if (st->codec->width == 1440) {
3348         data = avci50_1080i_extradata;
3349         size = sizeof(avci50_1080i_extradata);
3350     } else if (st->codec->width == 1280) {
3351         data = avci100_720p_extradata;
3352         size = sizeof(avci100_720p_extradata);
3353     }
3354
3355     if (!size)
3356         return 0;
3357
3358     av_freep(&st->codec->extradata);
3359     st->codec->extradata_size = 0;
3360     st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
3361     if (!st->codec->extradata)
3362         return AVERROR(ENOMEM);
3363
3364     memcpy(st->codec->extradata, data, size);
3365     st->codec->extradata_size = size;
3366
3367     return 0;
3368 }