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