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