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