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