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