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