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