Reimplement stream probe try #2
[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     }
2020 }
2021
2022 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
2023 {
2024     int64_t file_size;
2025
2026     /* get the file size, if possible */
2027     if (ic->iformat->flags & AVFMT_NOFILE) {
2028         file_size = 0;
2029     } else {
2030         file_size = avio_size(ic->pb);
2031         if (file_size < 0)
2032             file_size = 0;
2033     }
2034     ic->file_size = file_size;
2035
2036     if ((!strcmp(ic->iformat->name, "mpeg") ||
2037          !strcmp(ic->iformat->name, "mpegts")) &&
2038         file_size && !url_is_streamed(ic->pb)) {
2039         /* get accurate estimate from the PTSes */
2040         av_estimate_timings_from_pts(ic, old_offset);
2041     } else if (av_has_duration(ic)) {
2042         /* at least one component has timings - we use them for all
2043            the components */
2044         fill_all_stream_timings(ic);
2045     } else {
2046         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2047         /* less precise: use bitrate info */
2048         av_estimate_timings_from_bit_rate(ic);
2049     }
2050     av_update_stream_timings(ic);
2051
2052 #if 0
2053     {
2054         int i;
2055         AVStream *st;
2056         for(i = 0;i < ic->nb_streams; i++) {
2057             st = ic->streams[i];
2058         printf("%d: start_time: %0.3f duration: %0.3f\n",
2059                i, (double)st->start_time / AV_TIME_BASE,
2060                (double)st->duration / AV_TIME_BASE);
2061         }
2062         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2063                (double)ic->start_time / AV_TIME_BASE,
2064                (double)ic->duration / AV_TIME_BASE,
2065                ic->bit_rate / 1000);
2066     }
2067 #endif
2068 }
2069
2070 static int has_codec_parameters(AVCodecContext *enc)
2071 {
2072     int val;
2073     switch(enc->codec_type) {
2074     case AVMEDIA_TYPE_AUDIO:
2075         val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2076         if(!enc->frame_size &&
2077            (enc->codec_id == CODEC_ID_VORBIS ||
2078             enc->codec_id == CODEC_ID_AAC ||
2079             enc->codec_id == CODEC_ID_MP1 ||
2080             enc->codec_id == CODEC_ID_MP2 ||
2081             enc->codec_id == CODEC_ID_MP3 ||
2082             enc->codec_id == CODEC_ID_SPEEX))
2083             return 0;
2084         break;
2085     case AVMEDIA_TYPE_VIDEO:
2086         val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2087         break;
2088     default:
2089         val = 1;
2090         break;
2091     }
2092     return enc->codec_id != CODEC_ID_NONE && val != 0;
2093 }
2094
2095 static int has_decode_delay_been_guessed(AVStream *st)
2096 {
2097     return st->codec->codec_id != CODEC_ID_H264 ||
2098         st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2099 }
2100
2101 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2102 {
2103     int16_t *samples;
2104     AVCodec *codec;
2105     int got_picture, data_size, ret=0;
2106     AVFrame picture;
2107
2108     if(!st->codec->codec){
2109         codec = avcodec_find_decoder(st->codec->codec_id);
2110         if (!codec)
2111             return -1;
2112         ret = avcodec_open(st->codec, codec);
2113         if (ret < 0)
2114             return ret;
2115     }
2116
2117     if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2118         switch(st->codec->codec_type) {
2119         case AVMEDIA_TYPE_VIDEO:
2120             avcodec_get_frame_defaults(&picture);
2121             ret = avcodec_decode_video2(st->codec, &picture,
2122                                         &got_picture, avpkt);
2123             break;
2124         case AVMEDIA_TYPE_AUDIO:
2125             data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2126             samples = av_malloc(data_size);
2127             if (!samples)
2128                 goto fail;
2129             ret = avcodec_decode_audio3(st->codec, samples,
2130                                         &data_size, avpkt);
2131             av_free(samples);
2132             break;
2133         default:
2134             break;
2135         }
2136     }
2137  fail:
2138     return ret;
2139 }
2140
2141 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2142 {
2143     while (tags->id != CODEC_ID_NONE) {
2144         if (tags->id == id)
2145             return tags->tag;
2146         tags++;
2147     }
2148     return 0;
2149 }
2150
2151 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2152 {
2153     int i;
2154     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2155         if(tag == tags[i].tag)
2156             return tags[i].id;
2157     }
2158     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2159         if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2160             return tags[i].id;
2161     }
2162     return CODEC_ID_NONE;
2163 }
2164
2165 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2166 {
2167     int i;
2168     for(i=0; tags && tags[i]; i++){
2169         int tag= ff_codec_get_tag(tags[i], id);
2170         if(tag) return tag;
2171     }
2172     return 0;
2173 }
2174
2175 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2176 {
2177     int i;
2178     for(i=0; tags && tags[i]; i++){
2179         enum CodecID id= ff_codec_get_id(tags[i], tag);
2180         if(id!=CODEC_ID_NONE) return id;
2181     }
2182     return CODEC_ID_NONE;
2183 }
2184
2185 static void compute_chapters_end(AVFormatContext *s)
2186 {
2187     unsigned int i, j;
2188     int64_t max_time = s->duration + (s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time;
2189
2190     for (i = 0; i < s->nb_chapters; i++)
2191         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2192             AVChapter *ch = s->chapters[i];
2193             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2194                                      : INT64_MAX;
2195
2196             for (j = 0; j < s->nb_chapters; j++) {
2197                 AVChapter *ch1 = s->chapters[j];
2198                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2199                 if (j != i && next_start > ch->start && next_start < end)
2200                     end = next_start;
2201             }
2202             ch->end = (end == INT64_MAX) ? ch->start : end;
2203         }
2204 }
2205
2206 static int get_std_framerate(int i){
2207     if(i<60*12) return i*1001;
2208     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2209 }
2210
2211 /*
2212  * Is the time base unreliable.
2213  * This is a heuristic to balance between quick acceptance of the values in
2214  * the headers vs. some extra checks.
2215  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2216  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2217  * And there are "variable" fps files this needs to detect as well.
2218  */
2219 static int tb_unreliable(AVCodecContext *c){
2220     if(   c->time_base.den >= 101L*c->time_base.num
2221        || c->time_base.den <    5L*c->time_base.num
2222 /*       || c->codec_tag == AV_RL32("DIVX")
2223        || c->codec_tag == AV_RL32("XVID")*/
2224        || c->codec_id == CODEC_ID_MPEG2VIDEO
2225        || c->codec_id == CODEC_ID_H264
2226        )
2227         return 1;
2228     return 0;
2229 }
2230
2231 int av_find_stream_info(AVFormatContext *ic)
2232 {
2233     int i, count, ret, read_size, j;
2234     AVStream *st;
2235     AVPacket pkt1, *pkt;
2236     int64_t old_offset = avio_tell(ic->pb);
2237
2238     for(i=0;i<ic->nb_streams;i++) {
2239         AVCodec *codec;
2240         st = ic->streams[i];
2241         if (st->codec->codec_id == CODEC_ID_AAC) {
2242             st->codec->sample_rate = 0;
2243             st->codec->frame_size = 0;
2244             st->codec->channels = 0;
2245         }
2246         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2247             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2248 /*            if(!st->time_base.num)
2249                 st->time_base= */
2250             if(!st->codec->time_base.num)
2251                 st->codec->time_base= st->time_base;
2252         }
2253         //only for the split stuff
2254         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2255             st->parser = av_parser_init(st->codec->codec_id);
2256             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2257                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2258             }
2259         }
2260         assert(!st->codec->codec);
2261         codec = avcodec_find_decoder(st->codec->codec_id);
2262
2263         /* Force decoding of at least one frame of codec data
2264          * this makes sure the codec initializes the channel configuration
2265          * and does not trust the values from the container.
2266          */
2267         if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2268             st->codec->channels = 0;
2269
2270         /* Ensure that subtitle_header is properly set. */
2271         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2272             && codec && !st->codec->codec)
2273             avcodec_open(st->codec, codec);
2274
2275         //try to just open decoders, in case this is enough to get parameters
2276         if(!has_codec_parameters(st->codec)){
2277             if (codec && !st->codec->codec)
2278                 avcodec_open(st->codec, codec);
2279         }
2280     }
2281
2282     for (i=0; i<ic->nb_streams; i++) {
2283         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2284     }
2285
2286     count = 0;
2287     read_size = 0;
2288     for(;;) {
2289         if(url_interrupt_cb()){
2290             ret= AVERROR_EXIT;
2291             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2292             break;
2293         }
2294
2295         /* check if one codec still needs to be handled */
2296         for(i=0;i<ic->nb_streams;i++) {
2297             int fps_analyze_framecount = 20;
2298
2299             st = ic->streams[i];
2300             if (!has_codec_parameters(st->codec))
2301                 break;
2302             /* if the timebase is coarse (like the usual millisecond precision
2303                of mkv), we need to analyze more frames to reliably arrive at
2304                the correct fps */
2305             if (av_q2d(st->time_base) > 0.0005)
2306                 fps_analyze_framecount *= 2;
2307             /* variable fps and no guess at the real fps */
2308             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2309                && st->info->duration_count < fps_analyze_framecount
2310                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2311                 break;
2312             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2313                 break;
2314             if(st->first_dts == AV_NOPTS_VALUE)
2315                 break;
2316         }
2317         if (i == ic->nb_streams) {
2318             /* NOTE: if the format has no header, then we need to read
2319                some packets to get most of the streams, so we cannot
2320                stop here */
2321             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2322                 /* if we found the info for all the codecs, we can stop */
2323                 ret = count;
2324                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2325                 break;
2326             }
2327         }
2328         /* we did not get all the codec info, but we read too much data */
2329         if (read_size >= ic->probesize) {
2330             ret = count;
2331             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2332             break;
2333         }
2334
2335         /* NOTE: a new stream can be added there if no header in file
2336            (AVFMTCTX_NOHEADER) */
2337         ret = av_read_frame_internal(ic, &pkt1);
2338         if (ret < 0 && ret != AVERROR(EAGAIN)) {
2339             /* EOF or error */
2340             ret = -1; /* we could not have all the codec parameters before EOF */
2341             for(i=0;i<ic->nb_streams;i++) {
2342                 st = ic->streams[i];
2343                 if (!has_codec_parameters(st->codec)){
2344                     char buf[256];
2345                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2346                     av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2347                 } else {
2348                     ret = 0;
2349                 }
2350             }
2351             break;
2352         }
2353
2354         if (ret == AVERROR(EAGAIN))
2355             continue;
2356
2357         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2358         if ((ret = av_dup_packet(pkt)) < 0)
2359             goto find_stream_info_err;
2360
2361         read_size += pkt->size;
2362
2363         st = ic->streams[pkt->stream_index];
2364         if (st->codec_info_nb_frames>1) {
2365             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) {
2366                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2367                 break;
2368             }
2369             st->info->codec_info_duration += pkt->duration;
2370         }
2371         {
2372             int64_t last = st->info->last_dts;
2373             int64_t duration= pkt->dts - last;
2374
2375             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2376                 double dur= duration * av_q2d(st->time_base);
2377
2378 //                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2379 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2380                 if (st->info->duration_count < 2)
2381                     memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2382                 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2383                     int framerate= get_std_framerate(i);
2384                     int ticks= lrintf(dur*framerate/(1001*12));
2385                     double error= dur - ticks*1001*12/(double)framerate;
2386                     st->info->duration_error[i] += error*error;
2387                 }
2388                 st->info->duration_count++;
2389                 // ignore the first 4 values, they might have some random jitter
2390                 if (st->info->duration_count > 3)
2391                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2392             }
2393             if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2394                 st->info->last_dts = pkt->dts;
2395         }
2396         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2397             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2398             if(i){
2399                 st->codec->extradata_size= i;
2400                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2401                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2402                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2403             }
2404         }
2405
2406         /* if still no information, we try to open the codec and to
2407            decompress the frame. We try to avoid that in most cases as
2408            it takes longer and uses more memory. For MPEG-4, we need to
2409            decompress for QuickTime. */
2410         if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2411             try_decode_frame(st, pkt);
2412
2413         st->codec_info_nb_frames++;
2414         count++;
2415     }
2416
2417     // close codecs which were opened in try_decode_frame()
2418     for(i=0;i<ic->nb_streams;i++) {
2419         st = ic->streams[i];
2420         if(st->codec->codec)
2421             avcodec_close(st->codec);
2422     }
2423     for(i=0;i<ic->nb_streams;i++) {
2424         st = ic->streams[i];
2425         if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2426             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2427                      (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2428                       st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2429         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2430             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2431                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2432
2433             // the check for tb_unreliable() is not completely correct, since this is not about handling
2434             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2435             // ipmovie.c produces.
2436             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)
2437                 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);
2438             if (st->info->duration_count && !st->r_frame_rate.num
2439                && tb_unreliable(st->codec) /*&&
2440                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2441                st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2442                 int num = 0;
2443                 double best_error= 2*av_q2d(st->time_base);
2444                 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2445
2446                 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2447                     double error = st->info->duration_error[j] * get_std_framerate(j);
2448 //                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2449 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2450                     if(error < best_error){
2451                         best_error= error;
2452                         num = get_std_framerate(j);
2453                     }
2454                 }
2455                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2456                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2457                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2458             }
2459
2460             if (!st->r_frame_rate.num){
2461                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2462                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2463                     st->r_frame_rate.num = st->codec->time_base.den;
2464                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2465                 }else{
2466                     st->r_frame_rate.num = st->time_base.den;
2467                     st->r_frame_rate.den = st->time_base.num;
2468                 }
2469             }
2470         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2471             if(!st->codec->bits_per_coded_sample)
2472                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2473             // set stream disposition based on audio service type
2474             switch (st->codec->audio_service_type) {
2475             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2476                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2477             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2478                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2479             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2480                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2481             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2482                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2483             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2484                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2485             }
2486         }
2487     }
2488
2489     av_estimate_timings(ic, old_offset);
2490
2491     compute_chapters_end(ic);
2492
2493 #if 0
2494     /* correct DTS for B-frame streams with no timestamps */
2495     for(i=0;i<ic->nb_streams;i++) {
2496         st = ic->streams[i];
2497         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2498             if(b-frames){
2499                 ppktl = &ic->packet_buffer;
2500                 while(ppkt1){
2501                     if(ppkt1->stream_index != i)
2502                         continue;
2503                     if(ppkt1->pkt->dts < 0)
2504                         break;
2505                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2506                         break;
2507                     ppkt1->pkt->dts -= delta;
2508                     ppkt1= ppkt1->next;
2509                 }
2510                 if(ppkt1)
2511                     continue;
2512                 st->cur_dts -= delta;
2513             }
2514         }
2515     }
2516 #endif
2517
2518  find_stream_info_err:
2519     for (i=0; i < ic->nb_streams; i++)
2520         av_freep(&ic->streams[i]->info);
2521     return ret;
2522 }
2523
2524 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2525 {
2526     int i, j;
2527
2528     for (i = 0; i < ic->nb_programs; i++)
2529         for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2530             if (ic->programs[i]->stream_index[j] == s)
2531                 return ic->programs[i];
2532     return NULL;
2533 }
2534
2535 int av_find_best_stream(AVFormatContext *ic,
2536                         enum AVMediaType type,
2537                         int wanted_stream_nb,
2538                         int related_stream,
2539                         AVCodec **decoder_ret,
2540                         int flags)
2541 {
2542     int i, nb_streams = ic->nb_streams;
2543     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2544     unsigned *program = NULL;
2545     AVCodec *decoder = NULL, *best_decoder = NULL;
2546
2547     if (related_stream >= 0 && wanted_stream_nb < 0) {
2548         AVProgram *p = find_program_from_stream(ic, related_stream);
2549         if (p) {
2550             program = p->stream_index;
2551             nb_streams = p->nb_stream_indexes;
2552         }
2553     }
2554     for (i = 0; i < nb_streams; i++) {
2555         int real_stream_index = program ? program[i] : i;
2556         AVStream *st = ic->streams[real_stream_index];
2557         AVCodecContext *avctx = st->codec;
2558         if (avctx->codec_type != type)
2559             continue;
2560         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2561             continue;
2562         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2563             continue;
2564         if (decoder_ret) {
2565             decoder = avcodec_find_decoder(st->codec->codec_id);
2566             if (!decoder) {
2567                 if (ret < 0)
2568                     ret = AVERROR_DECODER_NOT_FOUND;
2569                 continue;
2570             }
2571         }
2572         if (best_count >= st->codec_info_nb_frames)
2573             continue;
2574         best_count = st->codec_info_nb_frames;
2575         ret = real_stream_index;
2576         best_decoder = decoder;
2577         if (program && i == nb_streams - 1 && ret < 0) {
2578             program = NULL;
2579             nb_streams = ic->nb_streams;
2580             i = 0; /* no related stream found, try again with everything */
2581         }
2582     }
2583     if (decoder_ret)
2584         *decoder_ret = best_decoder;
2585     return ret;
2586 }
2587
2588 /*******************************************************/
2589
2590 int av_read_play(AVFormatContext *s)
2591 {
2592     if (s->iformat->read_play)
2593         return s->iformat->read_play(s);
2594     if (s->pb)
2595         return ffio_read_pause(s->pb, 0);
2596     return AVERROR(ENOSYS);
2597 }
2598
2599 int av_read_pause(AVFormatContext *s)
2600 {
2601     if (s->iformat->read_pause)
2602         return s->iformat->read_pause(s);
2603     if (s->pb)
2604         return ffio_read_pause(s->pb, 1);
2605     return AVERROR(ENOSYS);
2606 }
2607
2608 void av_close_input_stream(AVFormatContext *s)
2609 {
2610     flush_packet_queue(s);
2611     if (s->iformat->read_close)
2612         s->iformat->read_close(s);
2613     avformat_free_context(s);
2614 }
2615
2616 void avformat_free_context(AVFormatContext *s)
2617 {
2618     int i;
2619     AVStream *st;
2620
2621     for(i=0;i<s->nb_streams;i++) {
2622         /* free all data in a stream component */
2623         st = s->streams[i];
2624         if (st->parser) {
2625             av_parser_close(st->parser);
2626             av_free_packet(&st->cur_pkt);
2627         }
2628         av_metadata_free(&st->metadata);
2629         av_free(st->index_entries);
2630         av_free(st->codec->extradata);
2631         av_free(st->codec->subtitle_header);
2632         av_free(st->codec);
2633 #if FF_API_OLD_METADATA
2634         av_free(st->filename);
2635 #endif
2636         av_free(st->priv_data);
2637         av_free(st->info);
2638         av_free(st);
2639     }
2640     for(i=s->nb_programs-1; i>=0; i--) {
2641 #if FF_API_OLD_METADATA
2642         av_freep(&s->programs[i]->provider_name);
2643         av_freep(&s->programs[i]->name);
2644 #endif
2645         av_metadata_free(&s->programs[i]->metadata);
2646         av_freep(&s->programs[i]->stream_index);
2647         av_freep(&s->programs[i]);
2648     }
2649     av_freep(&s->programs);
2650     av_freep(&s->priv_data);
2651     while(s->nb_chapters--) {
2652 #if FF_API_OLD_METADATA
2653         av_free(s->chapters[s->nb_chapters]->title);
2654 #endif
2655         av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2656         av_free(s->chapters[s->nb_chapters]);
2657     }
2658     av_freep(&s->chapters);
2659     av_metadata_free(&s->metadata);
2660     av_freep(&s->key);
2661     av_free(s);
2662 }
2663
2664 void av_close_input_file(AVFormatContext *s)
2665 {
2666     AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2667     av_close_input_stream(s);
2668     if (pb)
2669         avio_close(pb);
2670 }
2671
2672 AVStream *av_new_stream(AVFormatContext *s, int id)
2673 {
2674     AVStream *st;
2675     int i;
2676
2677 #if FF_API_MAX_STREAMS
2678     if (s->nb_streams >= MAX_STREAMS){
2679         av_log(s, AV_LOG_ERROR, "Too many streams\n");
2680         return NULL;
2681     }
2682 #else
2683     AVStream **streams;
2684
2685     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2686         return NULL;
2687     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2688     if (!streams)
2689         return NULL;
2690     s->streams = streams;
2691 #endif
2692
2693     st = av_mallocz(sizeof(AVStream));
2694     if (!st)
2695         return NULL;
2696     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2697         av_free(st);
2698         return NULL;
2699     }
2700
2701     st->codec= avcodec_alloc_context();
2702     if (s->iformat) {
2703         /* no default bitrate if decoding */
2704         st->codec->bit_rate = 0;
2705     }
2706     st->index = s->nb_streams;
2707     st->id = id;
2708     st->start_time = AV_NOPTS_VALUE;
2709     st->duration = AV_NOPTS_VALUE;
2710         /* we set the current DTS to 0 so that formats without any timestamps
2711            but durations get some timestamps, formats with some unknown
2712            timestamps have their first few packets buffered and the
2713            timestamps corrected before they are returned to the user */
2714     st->cur_dts = 0;
2715     st->first_dts = AV_NOPTS_VALUE;
2716     st->probe_packets = MAX_PROBE_PACKETS;
2717
2718     /* default pts setting is MPEG-like */
2719     av_set_pts_info(st, 33, 1, 90000);
2720     st->last_IP_pts = AV_NOPTS_VALUE;
2721     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2722         st->pts_buffer[i]= AV_NOPTS_VALUE;
2723     st->reference_dts = AV_NOPTS_VALUE;
2724
2725     st->sample_aspect_ratio = (AVRational){0,1};
2726
2727     s->streams[s->nb_streams++] = st;
2728     return st;
2729 }
2730
2731 AVProgram *av_new_program(AVFormatContext *ac, int id)
2732 {
2733     AVProgram *program=NULL;
2734     int i;
2735
2736 #ifdef DEBUG_SI
2737     av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2738 #endif
2739
2740     for(i=0; i<ac->nb_programs; i++)
2741         if(ac->programs[i]->id == id)
2742             program = ac->programs[i];
2743
2744     if(!program){
2745         program = av_mallocz(sizeof(AVProgram));
2746         if (!program)
2747             return NULL;
2748         dynarray_add(&ac->programs, &ac->nb_programs, program);
2749         program->discard = AVDISCARD_NONE;
2750     }
2751     program->id = id;
2752
2753     return program;
2754 }
2755
2756 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2757 {
2758     AVChapter *chapter = NULL;
2759     int i;
2760
2761     for(i=0; i<s->nb_chapters; i++)
2762         if(s->chapters[i]->id == id)
2763             chapter = s->chapters[i];
2764
2765     if(!chapter){
2766         chapter= av_mallocz(sizeof(AVChapter));
2767         if(!chapter)
2768             return NULL;
2769         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2770     }
2771 #if FF_API_OLD_METADATA
2772     av_free(chapter->title);
2773 #endif
2774     av_metadata_set2(&chapter->metadata, "title", title, 0);
2775     chapter->id    = id;
2776     chapter->time_base= time_base;
2777     chapter->start = start;
2778     chapter->end   = end;
2779
2780     return chapter;
2781 }
2782
2783 /************************************************************/
2784 /* output media file */
2785
2786 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2787 {
2788     int ret;
2789
2790     if (s->oformat->priv_data_size > 0) {
2791         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2792         if (!s->priv_data)
2793             return AVERROR(ENOMEM);
2794         if (s->oformat->priv_class) {
2795             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2796             av_opt_set_defaults(s->priv_data);
2797         }
2798     } else
2799         s->priv_data = NULL;
2800
2801     if (s->oformat->set_parameters) {
2802         ret = s->oformat->set_parameters(s, ap);
2803         if (ret < 0)
2804             return ret;
2805     }
2806     return 0;
2807 }
2808
2809 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2810 {
2811     const AVCodecTag *avctag;
2812     int n;
2813     enum CodecID id = CODEC_ID_NONE;
2814     unsigned int tag = 0;
2815
2816     /**
2817      * Check that tag + id is in the table
2818      * If neither is in the table -> OK
2819      * If tag is in the table with another id -> FAIL
2820      * If id is in the table with another tag -> FAIL unless strict < normal
2821      */
2822     for (n = 0; s->oformat->codec_tag[n]; n++) {
2823         avctag = s->oformat->codec_tag[n];
2824         while (avctag->id != CODEC_ID_NONE) {
2825             if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2826                 id = avctag->id;
2827                 if (id == st->codec->codec_id)
2828                     return 1;
2829             }
2830             if (avctag->id == st->codec->codec_id)
2831                 tag = avctag->tag;
2832             avctag++;
2833         }
2834     }
2835     if (id != CODEC_ID_NONE)
2836         return 0;
2837     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2838         return 0;
2839     return 1;
2840 }
2841
2842 int av_write_header(AVFormatContext *s)
2843 {
2844     int ret, i;
2845     AVStream *st;
2846
2847     // some sanity checks
2848     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2849         av_log(s, AV_LOG_ERROR, "no streams\n");
2850         return AVERROR(EINVAL);
2851     }
2852
2853     for(i=0;i<s->nb_streams;i++) {
2854         st = s->streams[i];
2855
2856         switch (st->codec->codec_type) {
2857         case AVMEDIA_TYPE_AUDIO:
2858             if(st->codec->sample_rate<=0){
2859                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2860                 return AVERROR(EINVAL);
2861             }
2862             if(!st->codec->block_align)
2863                 st->codec->block_align = st->codec->channels *
2864                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2865             break;
2866         case AVMEDIA_TYPE_VIDEO:
2867             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2868                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2869                 return AVERROR(EINVAL);
2870             }
2871             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2872                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2873                 return AVERROR(EINVAL);
2874             }
2875             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2876                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2877                 return AVERROR(EINVAL);
2878             }
2879             break;
2880         }
2881
2882         if(s->oformat->codec_tag){
2883             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)){
2884                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2885                 st->codec->codec_tag= 0;
2886             }
2887             if(st->codec->codec_tag){
2888                 if (!validate_codec_tag(s, st)) {
2889                     char tagbuf[32];
2890                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2891                     av_log(s, AV_LOG_ERROR,
2892                            "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2893                            tagbuf, st->codec->codec_tag, st->codec->codec_id);
2894                     return AVERROR_INVALIDDATA;
2895                 }
2896             }else
2897                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2898         }
2899
2900         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2901             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2902           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2903     }
2904
2905     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2906         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2907         if (!s->priv_data)
2908             return AVERROR(ENOMEM);
2909     }
2910
2911 #if FF_API_OLD_METADATA
2912     ff_metadata_mux_compat(s);
2913 #endif
2914
2915     /* set muxer identification string */
2916     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2917         av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2918     }
2919
2920     if(s->oformat->write_header){
2921         ret = s->oformat->write_header(s);
2922         if (ret < 0)
2923             return ret;
2924     }
2925
2926     /* init PTS generation */
2927     for(i=0;i<s->nb_streams;i++) {
2928         int64_t den = AV_NOPTS_VALUE;
2929         st = s->streams[i];
2930
2931         switch (st->codec->codec_type) {
2932         case AVMEDIA_TYPE_AUDIO:
2933             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2934             break;
2935         case AVMEDIA_TYPE_VIDEO:
2936             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2937             break;
2938         default:
2939             break;
2940         }
2941         if (den != AV_NOPTS_VALUE) {
2942             if (den <= 0)
2943                 return AVERROR_INVALIDDATA;
2944             av_frac_init(&st->pts, 0, 0, den);
2945         }
2946     }
2947     return 0;
2948 }
2949
2950 //FIXME merge with compute_pkt_fields
2951 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2952     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2953     int num, den, frame_size, i;
2954
2955     av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2956             pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2957
2958 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2959         return AVERROR(EINVAL);*/
2960
2961     /* duration field */
2962     if (pkt->duration == 0) {
2963         compute_frame_duration(&num, &den, st, NULL, pkt);
2964         if (den && num) {
2965             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2966         }
2967     }
2968
2969     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2970         pkt->pts= pkt->dts;
2971
2972     //XXX/FIXME this is a temporary hack until all encoders output pts
2973     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2974         pkt->dts=
2975 //        pkt->pts= st->cur_dts;
2976         pkt->pts= st->pts.val;
2977     }
2978
2979     //calculate dts from pts
2980     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2981         st->pts_buffer[0]= pkt->pts;
2982         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2983             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2984         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2985             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2986
2987         pkt->dts= st->pts_buffer[0];
2988     }
2989
2990     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2991         av_log(s, AV_LOG_ERROR,
2992                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2993                st->index, st->cur_dts, pkt->dts);
2994         return AVERROR(EINVAL);
2995     }
2996     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2997         av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2998         return AVERROR(EINVAL);
2999     }
3000
3001 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3002     st->cur_dts= pkt->dts;
3003     st->pts.val= pkt->dts;
3004
3005     /* update pts */
3006     switch (st->codec->codec_type) {
3007     case AVMEDIA_TYPE_AUDIO:
3008         frame_size = get_audio_frame_size(st->codec, pkt->size);
3009
3010         /* HACK/FIXME, we skip the initial 0 size packets as they are most
3011            likely equal to the encoder delay, but it would be better if we
3012            had the real timestamps from the encoder */
3013         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3014             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3015         }
3016         break;
3017     case AVMEDIA_TYPE_VIDEO:
3018         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3019         break;
3020     default:
3021         break;
3022     }
3023     return 0;
3024 }
3025
3026 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3027 {
3028     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3029
3030     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3031         return ret;
3032
3033     ret= s->oformat->write_packet(s, pkt);
3034     if(!ret)
3035         ret= url_ferror(s->pb);
3036     return ret;
3037 }
3038
3039 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3040                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3041 {
3042     AVPacketList **next_point, *this_pktl;
3043
3044     this_pktl = av_mallocz(sizeof(AVPacketList));
3045     this_pktl->pkt= *pkt;
3046     pkt->destruct= NULL;             // do not free original but only the copy
3047     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3048
3049     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3050         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3051     }else
3052         next_point = &s->packet_buffer;
3053
3054     if(*next_point){
3055         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3056             while(!compare(s, &(*next_point)->pkt, pkt)){
3057                 next_point= &(*next_point)->next;
3058             }
3059             goto next_non_null;
3060         }else{
3061             next_point = &(s->packet_buffer_end->next);
3062         }
3063     }
3064     assert(!*next_point);
3065
3066     s->packet_buffer_end= this_pktl;
3067 next_non_null:
3068
3069     this_pktl->next= *next_point;
3070
3071     s->streams[pkt->stream_index]->last_in_packet_buffer=
3072     *next_point= this_pktl;
3073 }
3074
3075 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3076 {
3077     AVStream *st = s->streams[ pkt ->stream_index];
3078     AVStream *st2= s->streams[ next->stream_index];
3079     int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3080     int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3081     return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
3082 }
3083
3084 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3085     AVPacketList *pktl;
3086     int stream_count=0;
3087     int i;
3088
3089     if(pkt){
3090         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3091     }
3092
3093     for(i=0; i < s->nb_streams; i++)
3094         stream_count+= !!s->streams[i]->last_in_packet_buffer;
3095
3096     if(stream_count && (s->nb_streams == stream_count || flush)){
3097         pktl= s->packet_buffer;
3098         *out= pktl->pkt;
3099
3100         s->packet_buffer= pktl->next;
3101         if(!s->packet_buffer)
3102             s->packet_buffer_end= NULL;
3103
3104         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3105             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3106         av_freep(&pktl);
3107         return 1;
3108     }else{
3109         av_init_packet(out);
3110         return 0;
3111     }
3112 }
3113
3114 /**
3115  * Interleave an AVPacket correctly so it can be muxed.
3116  * @param out the interleaved packet will be output here
3117  * @param in the input packet
3118  * @param flush 1 if no further packets are available as input and all
3119  *              remaining packets should be output
3120  * @return 1 if a packet was output, 0 if no packet could be output,
3121  *         < 0 if an error occurred
3122  */
3123 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3124     if(s->oformat->interleave_packet)
3125         return s->oformat->interleave_packet(s, out, in, flush);
3126     else
3127         return av_interleave_packet_per_dts(s, out, in, flush);
3128 }
3129
3130 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3131     AVStream *st= s->streams[ pkt->stream_index];
3132     int ret;
3133
3134     //FIXME/XXX/HACK drop zero sized packets
3135     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3136         return 0;
3137
3138     av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3139             pkt->size, pkt->dts, pkt->pts);
3140     if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3141         return ret;
3142
3143     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3144         return AVERROR(EINVAL);
3145
3146     for(;;){
3147         AVPacket opkt;
3148         int ret= av_interleave_packet(s, &opkt, pkt, 0);
3149         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3150             return ret;
3151
3152         ret= s->oformat->write_packet(s, &opkt);
3153
3154         av_free_packet(&opkt);
3155         pkt= NULL;
3156
3157         if(ret<0)
3158             return ret;
3159         if(url_ferror(s->pb))
3160             return url_ferror(s->pb);
3161     }
3162 }
3163
3164 int av_write_trailer(AVFormatContext *s)
3165 {
3166     int ret, i;
3167
3168     for(;;){
3169         AVPacket pkt;
3170         ret= av_interleave_packet(s, &pkt, NULL, 1);
3171         if(ret<0) //FIXME cleanup needed for ret<0 ?
3172             goto fail;
3173         if(!ret)
3174             break;
3175
3176         ret= s->oformat->write_packet(s, &pkt);
3177
3178         av_free_packet(&pkt);
3179
3180         if(ret<0)
3181             goto fail;
3182         if(url_ferror(s->pb))
3183             goto fail;
3184     }
3185
3186     if(s->oformat->write_trailer)
3187         ret = s->oformat->write_trailer(s);
3188 fail:
3189     if(ret == 0)
3190        ret=url_ferror(s->pb);
3191     for(i=0;i<s->nb_streams;i++) {
3192         av_freep(&s->streams[i]->priv_data);
3193         av_freep(&s->streams[i]->index_entries);
3194     }
3195     av_freep(&s->priv_data);
3196     return ret;
3197 }
3198
3199 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3200 {
3201     int i, j;
3202     AVProgram *program=NULL;
3203     void *tmp;
3204
3205     if (idx >= ac->nb_streams) {
3206         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3207         return;
3208     }
3209
3210     for(i=0; i<ac->nb_programs; i++){
3211         if(ac->programs[i]->id != progid)
3212             continue;
3213         program = ac->programs[i];
3214         for(j=0; j<program->nb_stream_indexes; j++)
3215             if(program->stream_index[j] == idx)
3216                 return;
3217
3218         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3219         if(!tmp)
3220             return;
3221         program->stream_index = tmp;
3222         program->stream_index[program->nb_stream_indexes++] = idx;
3223         return;
3224     }
3225 }
3226
3227 static void print_fps(double d, const char *postfix){
3228     uint64_t v= lrintf(d*100);
3229     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3230     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3231     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3232 }
3233
3234 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3235 {
3236     if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3237         AVMetadataTag *tag=NULL;
3238
3239         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3240         while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3241             if(strcmp("language", tag->key))
3242                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3243         }
3244     }
3245 }
3246
3247 /* "user interface" functions */
3248 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3249 {
3250     char buf[256];
3251     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3252     AVStream *st = ic->streams[i];
3253     int g = av_gcd(st->time_base.num, st->time_base.den);
3254     AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3255     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3256     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3257     /* the pid is an important information, so we display it */
3258     /* XXX: add a generic system */
3259     if (flags & AVFMT_SHOW_IDS)
3260         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3261     if (lang)
3262         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3263     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3264     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3265     if (st->sample_aspect_ratio.num && // default
3266         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3267         AVRational display_aspect_ratio;
3268         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3269                   st->codec->width*st->sample_aspect_ratio.num,
3270                   st->codec->height*st->sample_aspect_ratio.den,
3271                   1024*1024);
3272         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3273                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3274                  display_aspect_ratio.num, display_aspect_ratio.den);
3275     }
3276     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3277         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3278             print_fps(av_q2d(st->avg_frame_rate), "fps");
3279         if(st->r_frame_rate.den && st->r_frame_rate.num)
3280             print_fps(av_q2d(st->r_frame_rate), "tbr");
3281         if(st->time_base.den && st->time_base.num)
3282             print_fps(1/av_q2d(st->time_base), "tbn");
3283         if(st->codec->time_base.den && st->codec->time_base.num)
3284             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3285     }
3286     if (st->disposition & AV_DISPOSITION_DEFAULT)
3287         av_log(NULL, AV_LOG_INFO, " (default)");
3288     if (st->disposition & AV_DISPOSITION_DUB)
3289         av_log(NULL, AV_LOG_INFO, " (dub)");
3290     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3291         av_log(NULL, AV_LOG_INFO, " (original)");
3292     if (st->disposition & AV_DISPOSITION_COMMENT)
3293         av_log(NULL, AV_LOG_INFO, " (comment)");
3294     if (st->disposition & AV_DISPOSITION_LYRICS)
3295         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3296     if (st->disposition & AV_DISPOSITION_KARAOKE)
3297         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3298     if (st->disposition & AV_DISPOSITION_FORCED)
3299         av_log(NULL, AV_LOG_INFO, " (forced)");
3300     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3301         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3302     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3303         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3304     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3305         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3306     av_log(NULL, AV_LOG_INFO, "\n");
3307     dump_metadata(NULL, st->metadata, "    ");
3308 }
3309
3310 #if FF_API_DUMP_FORMAT
3311 void dump_format(AVFormatContext *ic,
3312                  int index,
3313                  const char *url,
3314                  int is_output)
3315 {
3316     av_dump_format(ic, index, url, is_output);
3317 }
3318 #endif
3319
3320 void av_dump_format(AVFormatContext *ic,
3321                     int index,
3322                     const char *url,
3323                     int is_output)
3324 {
3325     int i;
3326     uint8_t *printed = av_mallocz(ic->nb_streams);
3327     if (ic->nb_streams && !printed)
3328         return;
3329
3330     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3331             is_output ? "Output" : "Input",
3332             index,
3333             is_output ? ic->oformat->name : ic->iformat->name,
3334             is_output ? "to" : "from", url);
3335     dump_metadata(NULL, ic->metadata, "  ");
3336     if (!is_output) {
3337         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3338         if (ic->duration != AV_NOPTS_VALUE) {
3339             int hours, mins, secs, us;
3340             secs = ic->duration / AV_TIME_BASE;
3341             us = ic->duration % AV_TIME_BASE;
3342             mins = secs / 60;
3343             secs %= 60;
3344             hours = mins / 60;
3345             mins %= 60;
3346             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3347                    (100 * us) / AV_TIME_BASE);
3348         } else {
3349             av_log(NULL, AV_LOG_INFO, "N/A");
3350         }
3351         if (ic->start_time != AV_NOPTS_VALUE) {
3352             int secs, us;
3353             av_log(NULL, AV_LOG_INFO, ", start: ");
3354             secs = ic->start_time / AV_TIME_BASE;
3355             us = abs(ic->start_time % AV_TIME_BASE);
3356             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3357                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3358         }
3359         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3360         if (ic->bit_rate) {
3361             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3362         } else {
3363             av_log(NULL, AV_LOG_INFO, "N/A");
3364         }
3365         av_log(NULL, AV_LOG_INFO, "\n");
3366     }
3367     for (i = 0; i < ic->nb_chapters; i++) {
3368         AVChapter *ch = ic->chapters[i];
3369         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3370         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3371         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3372
3373         dump_metadata(NULL, ch->metadata, "    ");
3374     }
3375     if(ic->nb_programs) {
3376         int j, k, total = 0;
3377         for(j=0; j<ic->nb_programs; j++) {
3378             AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3379                                                   "name", NULL, 0);
3380             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3381                    name ? name->value : "");
3382             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3383             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3384                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3385                 printed[ic->programs[j]->stream_index[k]] = 1;
3386             }
3387             total += ic->programs[j]->nb_stream_indexes;
3388         }
3389         if (total < ic->nb_streams)
3390             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3391     }
3392     for(i=0;i<ic->nb_streams;i++)
3393         if (!printed[i])
3394             dump_stream_format(ic, i, index, is_output);
3395
3396     av_free(printed);
3397 }
3398
3399 #if FF_API_PARSE_FRAME_PARAM
3400 #include "libavutil/parseutils.h"
3401
3402 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3403 {
3404     return av_parse_video_size(width_ptr, height_ptr, str);
3405 }
3406
3407 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3408 {
3409     AVRational frame_rate;
3410     int ret = av_parse_video_rate(&frame_rate, arg);
3411     *frame_rate_num= frame_rate.num;
3412     *frame_rate_den= frame_rate.den;
3413     return ret;
3414 }
3415 #endif
3416
3417 int64_t av_gettime(void)
3418 {
3419     struct timeval tv;
3420     gettimeofday(&tv,NULL);
3421     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3422 }
3423
3424 uint64_t ff_ntp_time(void)
3425 {
3426   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3427 }
3428
3429 #if FF_API_PARSE_DATE
3430 #include "libavutil/parseutils.h"
3431
3432 int64_t parse_date(const char *timestr, int duration)
3433 {
3434     int64_t timeval;
3435     av_parse_time(&timeval, timestr, duration);
3436     return timeval;
3437 }
3438 #endif
3439
3440 #if FF_API_FIND_INFO_TAG
3441 #include "libavutil/parseutils.h"
3442
3443 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3444 {
3445     return av_find_info_tag(arg, arg_size, tag1, info);
3446 }
3447 #endif
3448
3449 int av_get_frame_filename(char *buf, int buf_size,
3450                           const char *path, int number)
3451 {
3452     const char *p;
3453     char *q, buf1[20], c;
3454     int nd, len, percentd_found;
3455
3456     q = buf;
3457     p = path;
3458     percentd_found = 0;
3459     for(;;) {
3460         c = *p++;
3461         if (c == '\0')
3462             break;
3463         if (c == '%') {
3464             do {
3465                 nd = 0;
3466                 while (isdigit(*p)) {
3467                     nd = nd * 10 + *p++ - '0';
3468                 }
3469                 c = *p++;
3470             } while (isdigit(c));
3471
3472             switch(c) {
3473             case '%':
3474                 goto addchar;
3475             case 'd':
3476                 if (percentd_found)
3477                     goto fail;
3478                 percentd_found = 1;
3479                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3480                 len = strlen(buf1);
3481                 if ((q - buf + len) > buf_size - 1)
3482                     goto fail;
3483                 memcpy(q, buf1, len);
3484                 q += len;
3485                 break;
3486             default:
3487                 goto fail;
3488             }
3489         } else {
3490         addchar:
3491             if ((q - buf) < buf_size - 1)
3492                 *q++ = c;
3493         }
3494     }
3495     if (!percentd_found)
3496         goto fail;
3497     *q = '\0';
3498     return 0;
3499  fail:
3500     *q = '\0';
3501     return -1;
3502 }
3503
3504 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3505 {
3506     int len, i, j, c;
3507 #undef fprintf
3508 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3509
3510     for(i=0;i<size;i+=16) {
3511         len = size - i;
3512         if (len > 16)
3513             len = 16;
3514         PRINT("%08x ", i);
3515         for(j=0;j<16;j++) {
3516             if (j < len)
3517                 PRINT(" %02x", buf[i+j]);
3518             else
3519                 PRINT("   ");
3520         }
3521         PRINT(" ");
3522         for(j=0;j<len;j++) {
3523             c = buf[i+j];
3524             if (c < ' ' || c > '~')
3525                 c = '.';
3526             PRINT("%c", c);
3527         }
3528         PRINT("\n");
3529     }
3530 #undef PRINT
3531 }
3532
3533 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3534 {
3535     hex_dump_internal(NULL, f, 0, buf, size);
3536 }
3537
3538 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3539 {
3540     hex_dump_internal(avcl, NULL, level, buf, size);
3541 }
3542
3543 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3544 {
3545 #undef fprintf
3546 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3547     PRINT("stream #%d:\n", pkt->stream_index);
3548     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3549     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3550     /* DTS is _always_ valid after av_read_frame() */
3551     PRINT("  dts=");
3552     if (pkt->dts == AV_NOPTS_VALUE)
3553         PRINT("N/A");
3554     else
3555         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3556     /* PTS may not be known if B-frames are present. */
3557     PRINT("  pts=");
3558     if (pkt->pts == AV_NOPTS_VALUE)
3559         PRINT("N/A");
3560     else
3561         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3562     PRINT("\n");
3563     PRINT("  size=%d\n", pkt->size);
3564 #undef PRINT
3565     if (dump_payload)
3566         av_hex_dump(f, pkt->data, pkt->size);
3567 }
3568
3569 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3570 {
3571     AVRational tb = { 1, AV_TIME_BASE };
3572     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3573 }
3574
3575 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3576 {
3577     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3578 }
3579
3580 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3581 {
3582     AVRational tb = { 1, AV_TIME_BASE };
3583     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3584 }
3585
3586 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3587                       AVStream *st)
3588 {
3589     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3590 }
3591
3592 #if FF_API_URL_SPLIT
3593 attribute_deprecated
3594 void ff_url_split(char *proto, int proto_size,
3595                   char *authorization, int authorization_size,
3596                   char *hostname, int hostname_size,
3597                   int *port_ptr,
3598                   char *path, int path_size,
3599                   const char *url)
3600 {
3601     av_url_split(proto, proto_size,
3602                  authorization, authorization_size,
3603                  hostname, hostname_size,
3604                  port_ptr,
3605                  path, path_size,
3606                  url);
3607 }
3608 #endif
3609
3610 void av_url_split(char *proto, int proto_size,
3611                   char *authorization, int authorization_size,
3612                   char *hostname, int hostname_size,
3613                   int *port_ptr,
3614                   char *path, int path_size,
3615                   const char *url)
3616 {
3617     const char *p, *ls, *at, *col, *brk;
3618
3619     if (port_ptr)               *port_ptr = -1;
3620     if (proto_size > 0)         proto[0] = 0;
3621     if (authorization_size > 0) authorization[0] = 0;
3622     if (hostname_size > 0)      hostname[0] = 0;
3623     if (path_size > 0)          path[0] = 0;
3624
3625     /* parse protocol */
3626     if ((p = strchr(url, ':'))) {
3627         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3628         p++; /* skip ':' */
3629         if (*p == '/') p++;
3630         if (*p == '/') p++;
3631     } else {
3632         /* no protocol means plain filename */
3633         av_strlcpy(path, url, path_size);
3634         return;
3635     }
3636
3637     /* separate path from hostname */
3638     ls = strchr(p, '/');
3639     if(!ls)
3640         ls = strchr(p, '?');
3641     if(ls)
3642         av_strlcpy(path, ls, path_size);
3643     else
3644         ls = &p[strlen(p)]; // XXX
3645
3646     /* the rest is hostname, use that to parse auth/port */
3647     if (ls != p) {
3648         /* authorization (user[:pass]@hostname) */
3649         if ((at = strchr(p, '@')) && at < ls) {
3650             av_strlcpy(authorization, p,
3651                        FFMIN(authorization_size, at + 1 - p));
3652             p = at + 1; /* skip '@' */
3653         }
3654
3655         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3656             /* [host]:port */
3657             av_strlcpy(hostname, p + 1,
3658                        FFMIN(hostname_size, brk - p));
3659             if (brk[1] == ':' && port_ptr)
3660                 *port_ptr = atoi(brk + 2);