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