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