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