lavf: don't guess r_frame_rate from either stream or codec timebase.
[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         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2394             if(!st->codec->bits_per_coded_sample)
2395                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2396             // set stream disposition based on audio service type
2397             switch (st->codec->audio_service_type) {
2398             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2399                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2400             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2401                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2402             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2403                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2404             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2405                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2406             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2407                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2408             }
2409         }
2410     }
2411
2412     estimate_timings(ic, old_offset);
2413
2414     compute_chapters_end(ic);
2415
2416 #if 0
2417     /* correct DTS for B-frame streams with no timestamps */
2418     for(i=0;i<ic->nb_streams;i++) {
2419         st = ic->streams[i];
2420         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2421             if(b-frames){
2422                 ppktl = &ic->packet_buffer;
2423                 while(ppkt1){
2424                     if(ppkt1->stream_index != i)
2425                         continue;
2426                     if(ppkt1->pkt->dts < 0)
2427                         break;
2428                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2429                         break;
2430                     ppkt1->pkt->dts -= delta;
2431                     ppkt1= ppkt1->next;
2432                 }
2433                 if(ppkt1)
2434                     continue;
2435                 st->cur_dts -= delta;
2436             }
2437         }
2438     }
2439 #endif
2440
2441  find_stream_info_err:
2442     for (i=0; i < ic->nb_streams; i++) {
2443         if (ic->streams[i]->codec)
2444             ic->streams[i]->codec->thread_count = 0;
2445         av_freep(&ic->streams[i]->info);
2446     }
2447     return ret;
2448 }
2449
2450 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2451 {
2452     int i, j;
2453
2454     for (i = 0; i < ic->nb_programs; i++)
2455         for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2456             if (ic->programs[i]->stream_index[j] == s)
2457                 return ic->programs[i];
2458     return NULL;
2459 }
2460
2461 int av_find_best_stream(AVFormatContext *ic,
2462                         enum AVMediaType type,
2463                         int wanted_stream_nb,
2464                         int related_stream,
2465                         AVCodec **decoder_ret,
2466                         int flags)
2467 {
2468     int i, nb_streams = ic->nb_streams;
2469     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2470     unsigned *program = NULL;
2471     AVCodec *decoder = NULL, *best_decoder = NULL;
2472
2473     if (related_stream >= 0 && wanted_stream_nb < 0) {
2474         AVProgram *p = find_program_from_stream(ic, related_stream);
2475         if (p) {
2476             program = p->stream_index;
2477             nb_streams = p->nb_stream_indexes;
2478         }
2479     }
2480     for (i = 0; i < nb_streams; i++) {
2481         int real_stream_index = program ? program[i] : i;
2482         AVStream *st = ic->streams[real_stream_index];
2483         AVCodecContext *avctx = st->codec;
2484         if (avctx->codec_type != type)
2485             continue;
2486         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2487             continue;
2488         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2489             continue;
2490         if (decoder_ret) {
2491             decoder = avcodec_find_decoder(st->codec->codec_id);
2492             if (!decoder) {
2493                 if (ret < 0)
2494                     ret = AVERROR_DECODER_NOT_FOUND;
2495                 continue;
2496             }
2497         }
2498         if (best_count >= st->codec_info_nb_frames)
2499             continue;
2500         best_count = st->codec_info_nb_frames;
2501         ret = real_stream_index;
2502         best_decoder = decoder;
2503         if (program && i == nb_streams - 1 && ret < 0) {
2504             program = NULL;
2505             nb_streams = ic->nb_streams;
2506             i = 0; /* no related stream found, try again with everything */
2507         }
2508     }
2509     if (decoder_ret)
2510         *decoder_ret = best_decoder;
2511     return ret;
2512 }
2513
2514 /*******************************************************/
2515
2516 int av_read_play(AVFormatContext *s)
2517 {
2518     if (s->iformat->read_play)
2519         return s->iformat->read_play(s);
2520     if (s->pb)
2521         return avio_pause(s->pb, 0);
2522     return AVERROR(ENOSYS);
2523 }
2524
2525 int av_read_pause(AVFormatContext *s)
2526 {
2527     if (s->iformat->read_pause)
2528         return s->iformat->read_pause(s);
2529     if (s->pb)
2530         return avio_pause(s->pb, 1);
2531     return AVERROR(ENOSYS);
2532 }
2533
2534 void avformat_free_context(AVFormatContext *s)
2535 {
2536     int i;
2537     AVStream *st;
2538
2539     av_opt_free(s);
2540     if (s->iformat && s->iformat->priv_class && s->priv_data)
2541         av_opt_free(s->priv_data);
2542
2543     for(i=0;i<s->nb_streams;i++) {
2544         /* free all data in a stream component */
2545         st = s->streams[i];
2546         if (st->parser) {
2547             av_parser_close(st->parser);
2548             av_free_packet(&st->cur_pkt);
2549         }
2550         av_dict_free(&st->metadata);
2551         av_free(st->index_entries);
2552         av_free(st->codec->extradata);
2553         av_free(st->codec->subtitle_header);
2554         av_free(st->codec);
2555         av_free(st->priv_data);
2556         av_free(st->info);
2557         av_free(st);
2558     }
2559     for(i=s->nb_programs-1; i>=0; i--) {
2560         av_dict_free(&s->programs[i]->metadata);
2561         av_freep(&s->programs[i]->stream_index);
2562         av_freep(&s->programs[i]);
2563     }
2564     av_freep(&s->programs);
2565     av_freep(&s->priv_data);
2566     while(s->nb_chapters--) {
2567         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2568         av_free(s->chapters[s->nb_chapters]);
2569     }
2570     av_freep(&s->chapters);
2571     av_dict_free(&s->metadata);
2572     av_freep(&s->streams);
2573     av_free(s);
2574 }
2575
2576 #if FF_API_CLOSE_INPUT_FILE
2577 void av_close_input_file(AVFormatContext *s)
2578 {
2579     avformat_close_input(&s);
2580 }
2581 #endif
2582
2583 void avformat_close_input(AVFormatContext **ps)
2584 {
2585     AVFormatContext *s = *ps;
2586     AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2587                        NULL : s->pb;
2588     flush_packet_queue(s);
2589     if (s->iformat->read_close)
2590         s->iformat->read_close(s);
2591     avformat_free_context(s);
2592     *ps = NULL;
2593     if (pb)
2594         avio_close(pb);
2595 }
2596
2597 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2598 {
2599     AVStream *st;
2600     int i;
2601     AVStream **streams;
2602
2603     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2604         return NULL;
2605     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2606     if (!streams)
2607         return NULL;
2608     s->streams = streams;
2609
2610     st = av_mallocz(sizeof(AVStream));
2611     if (!st)
2612         return NULL;
2613     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2614         av_free(st);
2615         return NULL;
2616     }
2617
2618     st->codec = avcodec_alloc_context3(c);
2619     if (s->iformat) {
2620         /* no default bitrate if decoding */
2621         st->codec->bit_rate = 0;
2622     }
2623     st->index = s->nb_streams;
2624     st->start_time = AV_NOPTS_VALUE;
2625     st->duration = AV_NOPTS_VALUE;
2626         /* we set the current DTS to 0 so that formats without any timestamps
2627            but durations get some timestamps, formats with some unknown
2628            timestamps have their first few packets buffered and the
2629            timestamps corrected before they are returned to the user */
2630     st->cur_dts = 0;
2631     st->first_dts = AV_NOPTS_VALUE;
2632     st->probe_packets = MAX_PROBE_PACKETS;
2633
2634     /* default pts setting is MPEG-like */
2635     avpriv_set_pts_info(st, 33, 1, 90000);
2636     st->last_IP_pts = AV_NOPTS_VALUE;
2637     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2638         st->pts_buffer[i]= AV_NOPTS_VALUE;
2639     st->reference_dts = AV_NOPTS_VALUE;
2640
2641     st->sample_aspect_ratio = (AVRational){0,1};
2642
2643     s->streams[s->nb_streams++] = st;
2644     return st;
2645 }
2646
2647 AVProgram *av_new_program(AVFormatContext *ac, int id)
2648 {
2649     AVProgram *program=NULL;
2650     int i;
2651
2652     av_dlog(ac, "new_program: id=0x%04x\n", id);
2653
2654     for(i=0; i<ac->nb_programs; i++)
2655         if(ac->programs[i]->id == id)
2656             program = ac->programs[i];
2657
2658     if(!program){
2659         program = av_mallocz(sizeof(AVProgram));
2660         if (!program)
2661             return NULL;
2662         dynarray_add(&ac->programs, &ac->nb_programs, program);
2663         program->discard = AVDISCARD_NONE;
2664     }
2665     program->id = id;
2666
2667     return program;
2668 }
2669
2670 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2671 {
2672     AVChapter *chapter = NULL;
2673     int i;
2674
2675     for(i=0; i<s->nb_chapters; i++)
2676         if(s->chapters[i]->id == id)
2677             chapter = s->chapters[i];
2678
2679     if(!chapter){
2680         chapter= av_mallocz(sizeof(AVChapter));
2681         if(!chapter)
2682             return NULL;
2683         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2684     }
2685     av_dict_set(&chapter->metadata, "title", title, 0);
2686     chapter->id    = id;
2687     chapter->time_base= time_base;
2688     chapter->start = start;
2689     chapter->end   = end;
2690
2691     return chapter;
2692 }
2693
2694 /************************************************************/
2695 /* output media file */
2696
2697 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2698 {
2699     const AVCodecTag *avctag;
2700     int n;
2701     enum CodecID id = CODEC_ID_NONE;
2702     unsigned int tag = 0;
2703
2704     /**
2705      * Check that tag + id is in the table
2706      * If neither is in the table -> OK
2707      * If tag is in the table with another id -> FAIL
2708      * If id is in the table with another tag -> FAIL unless strict < normal
2709      */
2710     for (n = 0; s->oformat->codec_tag[n]; n++) {
2711         avctag = s->oformat->codec_tag[n];
2712         while (avctag->id != CODEC_ID_NONE) {
2713             if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
2714                 id = avctag->id;
2715                 if (id == st->codec->codec_id)
2716                     return 1;
2717             }
2718             if (avctag->id == st->codec->codec_id)
2719                 tag = avctag->tag;
2720             avctag++;
2721         }
2722     }
2723     if (id != CODEC_ID_NONE)
2724         return 0;
2725     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2726         return 0;
2727     return 1;
2728 }
2729
2730 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2731 {
2732     int ret = 0, i;
2733     AVStream *st;
2734     AVDictionary *tmp = NULL;
2735
2736     if (options)
2737         av_dict_copy(&tmp, *options, 0);
2738     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2739         goto fail;
2740
2741     // some sanity checks
2742     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2743         av_log(s, AV_LOG_ERROR, "no streams\n");
2744         ret = AVERROR(EINVAL);
2745         goto fail;
2746     }
2747
2748     for(i=0;i<s->nb_streams;i++) {
2749         st = s->streams[i];
2750
2751         switch (st->codec->codec_type) {
2752         case AVMEDIA_TYPE_AUDIO:
2753             if(st->codec->sample_rate<=0){
2754                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2755                 ret = AVERROR(EINVAL);
2756                 goto fail;
2757             }
2758             if(!st->codec->block_align)
2759                 st->codec->block_align = st->codec->channels *
2760                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2761             break;
2762         case AVMEDIA_TYPE_VIDEO:
2763             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2764                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2765                 ret = AVERROR(EINVAL);
2766                 goto fail;
2767             }
2768             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2769                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2770                 ret = AVERROR(EINVAL);
2771                 goto fail;
2772             }
2773             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2774                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
2775                        "(%d/%d) and encoder layer (%d/%d)\n",
2776                        st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2777                        st->codec->sample_aspect_ratio.num,
2778                        st->codec->sample_aspect_ratio.den);
2779                 ret = AVERROR(EINVAL);
2780                 goto fail;
2781             }
2782             break;
2783         }
2784
2785         if(s->oformat->codec_tag){
2786             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)){
2787                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2788                 st->codec->codec_tag= 0;
2789             }
2790             if(st->codec->codec_tag){
2791                 if (!validate_codec_tag(s, st)) {
2792                     char tagbuf[32];
2793                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2794                     av_log(s, AV_LOG_ERROR,
2795                            "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2796                            tagbuf, st->codec->codec_tag, st->codec->codec_id);
2797                     ret = AVERROR_INVALIDDATA;
2798                     goto fail;
2799                 }
2800             }else
2801                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2802         }
2803
2804         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2805             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2806           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2807     }
2808
2809     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2810         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2811         if (!s->priv_data) {
2812             ret = AVERROR(ENOMEM);
2813             goto fail;
2814         }
2815         if (s->oformat->priv_class) {
2816             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2817             av_opt_set_defaults(s->priv_data);
2818             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2819                 goto fail;
2820         }
2821     }
2822
2823     /* set muxer identification string */
2824     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2825         av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2826     }
2827
2828     if(s->oformat->write_header){
2829         ret = s->oformat->write_header(s);
2830         if (ret < 0)
2831             goto fail;
2832     }
2833
2834     /* init PTS generation */
2835     for(i=0;i<s->nb_streams;i++) {
2836         int64_t den = AV_NOPTS_VALUE;
2837         st = s->streams[i];
2838
2839         switch (st->codec->codec_type) {
2840         case AVMEDIA_TYPE_AUDIO:
2841             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2842             break;
2843         case AVMEDIA_TYPE_VIDEO:
2844             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2845             break;
2846         default:
2847             break;
2848         }
2849         if (den != AV_NOPTS_VALUE) {
2850             if (den <= 0) {
2851                 ret = AVERROR_INVALIDDATA;
2852                 goto fail;
2853             }
2854             frac_init(&st->pts, 0, 0, den);
2855         }
2856     }
2857
2858     if (options) {
2859         av_dict_free(options);
2860         *options = tmp;
2861     }
2862     return 0;
2863 fail:
2864     av_dict_free(&tmp);
2865     return ret;
2866 }
2867
2868 //FIXME merge with compute_pkt_fields
2869 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2870     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2871     int num, den, frame_size, i;
2872
2873     av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2874             pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2875
2876 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2877         return AVERROR(EINVAL);*/
2878
2879     /* duration field */
2880     if (pkt->duration == 0) {
2881         compute_frame_duration(&num, &den, st, NULL, pkt);
2882         if (den && num) {
2883             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2884         }
2885     }
2886
2887     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2888         pkt->pts= pkt->dts;
2889
2890     //XXX/FIXME this is a temporary hack until all encoders output pts
2891     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2892         pkt->dts=
2893 //        pkt->pts= st->cur_dts;
2894         pkt->pts= st->pts.val;
2895     }
2896
2897     //calculate dts from pts
2898     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2899         st->pts_buffer[0]= pkt->pts;
2900         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2901             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2902         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2903             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2904
2905         pkt->dts= st->pts_buffer[0];
2906     }
2907
2908     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2909         av_log(s, AV_LOG_ERROR,
2910                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2911                st->index, st->cur_dts, pkt->dts);
2912         return AVERROR(EINVAL);
2913     }
2914     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2915         av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2916         return AVERROR(EINVAL);
2917     }
2918
2919 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2920     st->cur_dts= pkt->dts;
2921     st->pts.val= pkt->dts;
2922
2923     /* update pts */
2924     switch (st->codec->codec_type) {
2925     case AVMEDIA_TYPE_AUDIO:
2926         frame_size = get_audio_frame_size(st->codec, pkt->size);
2927
2928         /* HACK/FIXME, we skip the initial 0 size packets as they are most
2929            likely equal to the encoder delay, but it would be better if we
2930            had the real timestamps from the encoder */
2931         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2932             frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2933         }
2934         break;
2935     case AVMEDIA_TYPE_VIDEO:
2936         frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2937         break;
2938     default:
2939         break;
2940     }
2941     return 0;
2942 }
2943
2944 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2945 {
2946     int ret;
2947
2948     if (!pkt) {
2949         if (s->oformat->flags & AVFMT_ALLOW_FLUSH)
2950             return s->oformat->write_packet(s, pkt);
2951         return 1;
2952     }
2953
2954     ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2955
2956     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2957         return ret;
2958
2959     ret= s->oformat->write_packet(s, pkt);
2960
2961     if (ret >= 0)
2962         s->streams[pkt->stream_index]->nb_frames++;
2963     return ret;
2964 }
2965
2966 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2967                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2968 {
2969     AVPacketList **next_point, *this_pktl;
2970
2971     this_pktl = av_mallocz(sizeof(AVPacketList));
2972     this_pktl->pkt= *pkt;
2973     pkt->destruct= NULL;             // do not free original but only the copy
2974     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2975
2976     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2977         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2978     }else
2979         next_point = &s->packet_buffer;
2980
2981     if(*next_point){
2982         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2983             while(!compare(s, &(*next_point)->pkt, pkt)){
2984                 next_point= &(*next_point)->next;
2985             }
2986             goto next_non_null;
2987         }else{
2988             next_point = &(s->packet_buffer_end->next);
2989         }
2990     }
2991     assert(!*next_point);
2992
2993     s->packet_buffer_end= this_pktl;
2994 next_non_null:
2995
2996     this_pktl->next= *next_point;
2997
2998     s->streams[pkt->stream_index]->last_in_packet_buffer=
2999     *next_point= this_pktl;
3000 }
3001
3002 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3003 {
3004     AVStream *st = s->streams[ pkt ->stream_index];
3005     AVStream *st2= s->streams[ next->stream_index];
3006     int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3007                              st->time_base);
3008
3009     if (comp == 0)
3010         return pkt->stream_index < next->stream_index;
3011     return comp > 0;
3012 }
3013
3014 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3015     AVPacketList *pktl;
3016     int stream_count=0;
3017     int i;
3018
3019     if(pkt){
3020         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3021     }
3022
3023     for(i=0; i < s->nb_streams; i++)
3024         stream_count+= !!s->streams[i]->last_in_packet_buffer;
3025
3026     if(stream_count && (s->nb_streams == stream_count || flush)){
3027         pktl= s->packet_buffer;
3028         *out= pktl->pkt;
3029
3030         s->packet_buffer= pktl->next;
3031         if(!s->packet_buffer)
3032             s->packet_buffer_end= NULL;
3033
3034         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3035             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3036         av_freep(&pktl);
3037         return 1;
3038     }else{
3039         av_init_packet(out);
3040         return 0;
3041     }
3042 }
3043
3044 /**
3045  * Interleave an AVPacket correctly so it can be muxed.
3046  * @param out the interleaved packet will be output here
3047  * @param in the input packet
3048  * @param flush 1 if no further packets are available as input and all
3049  *              remaining packets should be output
3050  * @return 1 if a packet was output, 0 if no packet could be output,
3051  *         < 0 if an error occurred
3052  */
3053 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3054     if (s->oformat->interleave_packet) {
3055         int ret = s->oformat->interleave_packet(s, out, in, flush);
3056         if (in)
3057             av_free_packet(in);
3058         return ret;
3059     } else
3060         return av_interleave_packet_per_dts(s, out, in, flush);
3061 }
3062
3063 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3064     AVStream *st= s->streams[ pkt->stream_index];
3065     int ret;
3066
3067     //FIXME/XXX/HACK drop zero sized packets
3068     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3069         return 0;
3070
3071     av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3072             pkt->size, pkt->dts, pkt->pts);
3073     if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3074         return ret;
3075
3076     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3077         return AVERROR(EINVAL);
3078
3079     for(;;){
3080         AVPacket opkt;
3081         int ret= interleave_packet(s, &opkt, pkt, 0);
3082         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3083             return ret;
3084
3085         ret= s->oformat->write_packet(s, &opkt);
3086         if (ret >= 0)
3087             s->streams[opkt.stream_index]->nb_frames++;
3088
3089         av_free_packet(&opkt);
3090         pkt= NULL;
3091
3092         if(ret<0)
3093             return ret;
3094     }
3095 }
3096
3097 int av_write_trailer(AVFormatContext *s)
3098 {
3099     int ret, i;
3100
3101     for(;;){
3102         AVPacket pkt;
3103         ret= interleave_packet(s, &pkt, NULL, 1);
3104         if(ret<0) //FIXME cleanup needed for ret<0 ?
3105             goto fail;
3106         if(!ret)
3107             break;
3108
3109         ret= s->oformat->write_packet(s, &pkt);
3110         if (ret >= 0)
3111             s->streams[pkt.stream_index]->nb_frames++;
3112
3113         av_free_packet(&pkt);
3114
3115         if(ret<0)
3116             goto fail;
3117     }
3118
3119     if(s->oformat->write_trailer)
3120         ret = s->oformat->write_trailer(s);
3121 fail:
3122     for(i=0;i<s->nb_streams;i++) {
3123         av_freep(&s->streams[i]->priv_data);
3124         av_freep(&s->streams[i]->index_entries);
3125     }
3126     if (s->oformat->priv_class)
3127         av_opt_free(s->priv_data);
3128     av_freep(&s->priv_data);
3129     return ret;
3130 }
3131
3132 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3133 {
3134     int i, j;
3135     AVProgram *program=NULL;
3136     void *tmp;
3137
3138     if (idx >= ac->nb_streams) {
3139         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3140         return;
3141     }
3142
3143     for(i=0; i<ac->nb_programs; i++){
3144         if(ac->programs[i]->id != progid)
3145             continue;
3146         program = ac->programs[i];
3147         for(j=0; j<program->nb_stream_indexes; j++)
3148             if(program->stream_index[j] == idx)
3149                 return;
3150
3151         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3152         if(!tmp)
3153             return;
3154         program->stream_index = tmp;
3155         program->stream_index[program->nb_stream_indexes++] = idx;
3156         return;
3157     }
3158 }
3159
3160 static void print_fps(double d, const char *postfix){
3161     uint64_t v= lrintf(d*100);
3162     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3163     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3164     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3165 }
3166
3167 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3168 {
3169     if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3170         AVDictionaryEntry *tag=NULL;
3171
3172         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3173         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3174             if(strcmp("language", tag->key))
3175                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3176         }
3177     }
3178 }
3179
3180 /* "user interface" functions */
3181 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3182 {
3183     char buf[256];
3184     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3185     AVStream *st = ic->streams[i];
3186     int g = av_gcd(st->time_base.num, st->time_base.den);
3187     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3188     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3189     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3190     /* the pid is an important information, so we display it */
3191     /* XXX: add a generic system */
3192     if (flags & AVFMT_SHOW_IDS)
3193         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3194     if (lang)
3195         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3196     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3197     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3198     if (st->sample_aspect_ratio.num && // default
3199         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3200         AVRational display_aspect_ratio;
3201         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3202                   st->codec->width*st->sample_aspect_ratio.num,
3203                   st->codec->height*st->sample_aspect_ratio.den,
3204                   1024*1024);
3205         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3206                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3207                  display_aspect_ratio.num, display_aspect_ratio.den);
3208     }
3209     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3210         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3211             print_fps(av_q2d(st->avg_frame_rate), "fps");
3212         if(st->r_frame_rate.den && st->r_frame_rate.num)
3213             print_fps(av_q2d(st->r_frame_rate), "tbr");
3214         if(st->time_base.den && st->time_base.num)
3215             print_fps(1/av_q2d(st->time_base), "tbn");
3216         if(st->codec->time_base.den && st->codec->time_base.num)
3217             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3218     }
3219     if (st->disposition & AV_DISPOSITION_DEFAULT)
3220         av_log(NULL, AV_LOG_INFO, " (default)");
3221     if (st->disposition & AV_DISPOSITION_DUB)
3222         av_log(NULL, AV_LOG_INFO, " (dub)");
3223     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3224         av_log(NULL, AV_LOG_INFO, " (original)");
3225     if (st->disposition & AV_DISPOSITION_COMMENT)
3226         av_log(NULL, AV_LOG_INFO, " (comment)");
3227     if (st->disposition & AV_DISPOSITION_LYRICS)
3228         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3229     if (st->disposition & AV_DISPOSITION_KARAOKE)
3230         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3231     if (st->disposition & AV_DISPOSITION_FORCED)
3232         av_log(NULL, AV_LOG_INFO, " (forced)");
3233     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3234         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3235     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3236         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3237     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3238         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3239     av_log(NULL, AV_LOG_INFO, "\n");
3240     dump_metadata(NULL, st->metadata, "    ");
3241 }
3242
3243 void av_dump_format(AVFormatContext *ic,
3244                     int index,
3245                     const char *url,
3246                     int is_output)
3247 {
3248     int i;
3249     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3250     if (ic->nb_streams && !printed)
3251         return;
3252
3253     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3254             is_output ? "Output" : "Input",
3255             index,
3256             is_output ? ic->oformat->name : ic->iformat->name,
3257             is_output ? "to" : "from", url);
3258     dump_metadata(NULL, ic->metadata, "  ");
3259     if (!is_output) {
3260         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3261         if (ic->duration != AV_NOPTS_VALUE) {
3262             int hours, mins, secs, us;
3263             secs = ic->duration / AV_TIME_BASE;
3264             us = ic->duration % AV_TIME_BASE;
3265             mins = secs / 60;
3266             secs %= 60;
3267             hours = mins / 60;
3268             mins %= 60;
3269             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3270                    (100 * us) / AV_TIME_BASE);
3271         } else {
3272             av_log(NULL, AV_LOG_INFO, "N/A");
3273         }
3274         if (ic->start_time != AV_NOPTS_VALUE) {
3275             int secs, us;
3276             av_log(NULL, AV_LOG_INFO, ", start: ");
3277             secs = ic->start_time / AV_TIME_BASE;
3278             us = abs(ic->start_time % AV_TIME_BASE);
3279             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3280                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3281         }
3282         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3283         if (ic->bit_rate) {
3284             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3285         } else {
3286             av_log(NULL, AV_LOG_INFO, "N/A");
3287         }
3288         av_log(NULL, AV_LOG_INFO, "\n");
3289     }
3290     for (i = 0; i < ic->nb_chapters; i++) {
3291         AVChapter *ch = ic->chapters[i];
3292         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3293         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3294         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3295
3296         dump_metadata(NULL, ch->metadata, "    ");
3297     }
3298     if(ic->nb_programs) {
3299         int j, k, total = 0;
3300         for(j=0; j<ic->nb_programs; j++) {
3301             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3302                                                   "name", NULL, 0);
3303             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3304                    name ? name->value : "");
3305             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3306             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3307                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3308                 printed[ic->programs[j]->stream_index[k]] = 1;
3309             }
3310             total += ic->programs[j]->nb_stream_indexes;
3311         }
3312         if (total < ic->nb_streams)
3313             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3314     }
3315     for(i=0;i<ic->nb_streams;i++)
3316         if (!printed[i])
3317             dump_stream_format(ic, i, index, is_output);
3318
3319     av_free(printed);
3320 }
3321
3322 int64_t av_gettime(void)
3323 {
3324     struct timeval tv;
3325     gettimeofday(&tv,NULL);
3326     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3327 }
3328
3329 uint64_t ff_ntp_time(void)
3330 {
3331   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3332 }
3333
3334 int av_get_frame_filename(char *buf, int buf_size,
3335                           const char *path, int number)
3336 {
3337     const char *p;
3338     char *q, buf1[20], c;
3339     int nd, len, percentd_found;
3340
3341     q = buf;
3342     p = path;
3343     percentd_found = 0;
3344     for(;;) {
3345         c = *p++;
3346         if (c == '\0')
3347             break;
3348         if (c == '%') {
3349             do {
3350                 nd = 0;
3351                 while (isdigit(*p)) {
3352                     nd = nd * 10 + *p++ - '0';
3353                 }
3354                 c = *p++;
3355             } while (isdigit(c));
3356
3357             switch(c) {
3358             case '%':
3359                 goto addchar;
3360             case 'd':
3361                 if (percentd_found)
3362                     goto fail;
3363                 percentd_found = 1;
3364                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3365                 len = strlen(buf1);
3366                 if ((q - buf + len) > buf_size - 1)
3367                     goto fail;
3368                 memcpy(q, buf1, len);
3369                 q += len;
3370                 break;
3371             default:
3372                 goto fail;
3373             }
3374         } else {
3375         addchar:
3376             if ((q - buf) < buf_size - 1)
3377                 *q++ = c;
3378         }
3379     }
3380     if (!percentd_found)
3381         goto fail;
3382     *q = '\0';
3383     return 0;
3384  fail:
3385     *q = '\0';
3386     return -1;
3387 }
3388
3389 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3390 {
3391     int len, i, j, c;
3392 #undef fprintf
3393 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3394
3395     for(i=0;i<size;i+=16) {
3396         len = size - i;
3397         if (len > 16)
3398             len = 16;
3399         PRINT("%08x ", i);
3400         for(j=0;j<16;j++) {
3401             if (j < len)
3402                 PRINT(" %02x", buf[i+j]);
3403             else
3404                 PRINT("   ");
3405         }
3406         PRINT(" ");
3407         for(j=0;j<len;j++) {
3408             c = buf[i+j];
3409             if (c < ' ' || c > '~')
3410                 c = '.';
3411             PRINT("%c", c);
3412         }
3413         PRINT("\n");
3414     }
3415 #undef PRINT
3416 }
3417
3418 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3419 {
3420     hex_dump_internal(NULL, f, 0, buf, size);
3421 }
3422
3423 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3424 {
3425     hex_dump_internal(avcl, NULL, level, buf, size);
3426 }
3427
3428 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3429 {
3430 #undef fprintf
3431 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3432     PRINT("stream #%d:\n", pkt->stream_index);
3433     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3434     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3435     /* DTS is _always_ valid after av_read_frame() */
3436     PRINT("  dts=");
3437     if (pkt->dts == AV_NOPTS_VALUE)
3438         PRINT("N/A");
3439     else
3440         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3441     /* PTS may not be known if B-frames are present. */
3442     PRINT("  pts=");
3443     if (pkt->pts == AV_NOPTS_VALUE)
3444         PRINT("N/A");
3445     else
3446         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3447     PRINT("\n");
3448     PRINT("  size=%d\n", pkt->size);
3449 #undef PRINT
3450     if (dump_payload)
3451         av_hex_dump(f, pkt->data, pkt->size);
3452 }
3453
3454 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3455 {
3456     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3457 }
3458
3459 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3460                       AVStream *st)
3461 {
3462     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3463 }
3464
3465 void av_url_split(char *proto, int proto_size,
3466                   char *authorization, int authorization_size,
3467                   char *hostname, int hostname_size,
3468                   int *port_ptr,
3469                   char *path, int path_size,
3470                   const char *url)
3471 {
3472     const char *p, *ls, *at, *col, *brk;
3473
3474     if (port_ptr)               *port_ptr = -1;
3475     if (proto_size > 0)         proto[0] = 0;
3476     if (authorization_size > 0) authorization[0] = 0;
3477     if (hostname_size > 0)      hostname[0] = 0;
3478     if (path_size > 0)          path[0] = 0;
3479
3480     /* parse protocol */
3481     if ((p = strchr(url, ':'))) {
3482         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3483         p++; /* skip ':' */
3484         if (*p == '/') p++;
3485         if (*p == '/') p++;
3486     } else {
3487         /* no protocol means plain filename */
3488         av_strlcpy(path, url, path_size);
3489         return;
3490     }
3491
3492     /* separate path from hostname */
3493     ls = strchr(p, '/');
3494     if(!ls)
3495         ls = strchr(p, '?');
3496     if(ls)
3497         av_strlcpy(path, ls, path_size);
3498     else
3499         ls = &p[strlen(p)]; // XXX
3500
3501     /* the rest is hostname, use that to parse auth/port */
3502     if (ls != p) {
3503         /* authorization (user[:pass]@hostname) */
3504         if ((at = strchr(p, '@')) && at < ls) {
3505             av_strlcpy(authorization, p,
3506                        FFMIN(authorization_size, at + 1 - p));
3507             p = at + 1; /* skip '@' */
3508         }
3509
3510         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3511             /* [host]:port */
3512             av_strlcpy(hostname, p + 1,
3513                        FFMIN(hostname_size, brk - p));
3514             if (brk[1] == ':' && port_ptr)
3515                 *port_ptr = atoi(brk + 2);
3516         } else if ((col = strchr(p, ':')) && col < ls) {
3517             av_strlcpy(hostname, p,
3518                        FFMIN(col + 1 - p, hostname_size));
3519             if (port_ptr) *port_ptr = atoi(col + 1);
3520         } else
3521             av_strlcpy(hostname, p,
3522                        FFMIN(ls + 1 - p, hostname_size));
3523     }
3524 }
3525
3526 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3527 {
3528     int i;
3529     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3530                                            '4', '5', '6', '7',
3531                                            '8', '9', 'A', 'B',
3532                                            'C', 'D', 'E', 'F' };
3533     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3534                                            '4', '5', '6', '7',
3535                                            '8', '9', 'a', 'b',
3536                                            'c', 'd', 'e', 'f' };
3537     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3538
3539     for(i = 0; i < s; i++) {
3540         buff[i * 2]     = hex_table[src[i] >> 4];
3541         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3542     }
3543
3544     return buff;
3545 }
3546
3547 int ff_hex_to_data(uint8_t *data, const char *p)
3548 {
3549     int c, len, v;
3550
3551     len = 0;
3552     v = 1;
3553     for (;;) {
3554         p += strspn(p, SPACE_CHARS);
3555         if (*p == '\0')
3556             break;
3557         c = toupper((unsigned char) *p++);
3558         if (c >= '0' && c <= '9')
3559             c = c - '0';
3560         else if (c >= 'A' && c <= 'F')
3561             c = c - 'A' + 10;
3562         else
3563             break;
3564         v = (v << 4) | c;
3565         if (v & 0x100) {
3566             if (data)
3567                 data[len] = v;
3568             len++;
3569             v = 1;
3570         }
3571     }
3572     return len;
3573 }
3574
3575 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3576                          unsigned int pts_num, unsigned int pts_den)
3577 {
3578     AVRational new_tb;
3579     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3580         if(new_tb.num != pts_num)
3581             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3582     }else
3583         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3584
3585     if(new_tb.num <= 0 || new_tb.den <= 0) {
3586         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3587         return;
3588     }
3589     s->time_base = new_tb;
3590     s->pts_wrap_bits = pts_wrap_bits;
3591 }
3592
3593 int ff_url_join(char *str, int size, const char *proto,
3594                 const char *authorization, const char *hostname,
3595                 int port, const char *fmt, ...)
3596 {
3597 #if CONFIG_NETWORK
3598     struct addrinfo hints, *ai;
3599 #endif
3600
3601     str[0] = '\0';
3602     if (proto)
3603         av_strlcatf(str, size, "%s://", proto);
3604     if (authorization && authorization[0])
3605         av_strlcatf(str, size, "%s@", authorization);
3606 #if CONFIG_NETWORK && defined(AF_INET6)
3607     /* Determine if hostname is a numerical IPv6 address,
3608      * properly escape it within [] in that case. */
3609     memset(&hints, 0, sizeof(hints));
3610     hints.ai_flags = AI_NUMERICHOST;
3611     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3612         if (ai->ai_family == AF_INET6) {
3613             av_strlcat(str, "[", size);
3614             av_strlcat(str, hostname, size);
3615             av_strlcat(str, "]", size);
3616         } else {
3617             av_strlcat(str, hostname, size);
3618         }
3619         freeaddrinfo(ai);
3620     } else
3621 #endif
3622         /* Not an IPv6 address, just output the plain string. */
3623         av_strlcat(str, hostname, size);
3624
3625     if (port >= 0)
3626         av_strlcatf(str, size, ":%d", port);
3627     if (fmt) {
3628         va_list vl;
3629         int len = strlen(str);
3630
3631         va_start(vl, fmt);
3632         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3633         va_end(vl);
3634     }
3635     return strlen(str);
3636 }
3637
3638 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3639                      AVFormatContext *src)
3640 {
3641     AVPacket local_pkt;
3642
3643     local_pkt = *pkt;
3644     local_pkt.stream_index = dst_stream;
3645     if (pkt->pts != AV_NOPTS_VALUE)
3646         local_pkt.pts = av_rescale_q(pkt->pts,
3647                                      src->streams[pkt->stream_index]->time_base,
3648                                      dst->streams[dst_stream]->time_base);
3649     if (pkt->dts != AV_NOPTS_VALUE)
3650         local_pkt.dts = av_rescale_q(pkt->dts,
3651                                      src->streams[pkt->stream_index]->time_base,
3652                                      dst->streams[dst_stream]->time_base);
3653     return av_write_frame(dst, &local_pkt);
3654 }
3655
3656 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3657                         void *context)
3658 {
3659     const char *ptr = str;
3660
3661     /* Parse key=value pairs. */
3662     for (;;) {
3663         const char *key;
3664         char *dest = NULL, *dest_end;
3665         int key_len, dest_len = 0;
3666
3667         /* Skip whitespace and potential commas. */
3668         while (*ptr && (isspace(*ptr) || *ptr == ','))
3669             ptr++;
3670         if (!*ptr)
3671             break;
3672
3673         key = ptr;
3674
3675         if (!(ptr = strchr(key, '=')))
3676             break;
3677         ptr++;
3678         key_len = ptr - key;
3679
3680         callback_get_buf(context, key, key_len, &dest, &dest_len);
3681         dest_end = dest + dest_len - 1;
3682
3683         if (*ptr == '\"') {
3684             ptr++;
3685             while (*ptr && *ptr != '\"') {
3686                 if (*ptr == '\\') {
3687                     if (!ptr[1])
3688                         break;
3689                     if (dest && dest < dest_end)
3690                         *dest++ = ptr[1];
3691                     ptr += 2;
3692                 } else {
3693                     if (dest && dest < dest_end)
3694                         *dest++ = *ptr;
3695                     ptr++;
3696                 }
3697             }
3698             if (*ptr == '\"')
3699                 ptr++;
3700         } else {
3701             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3702                 if (dest && dest < dest_end)
3703                     *dest++ = *ptr;
3704         }
3705         if (dest)
3706             *dest = 0;
3707     }
3708 }
3709
3710 int ff_find_stream_index(AVFormatContext *s, int id)
3711 {
3712     int i;
3713     for (i = 0; i < s->nb_streams; i++) {
3714         if (s->streams[i]->id == id)
3715             return i;
3716     }
3717     return -1;
3718 }
3719
3720 void ff_make_absolute_url(char *buf, int size, const char *base,
3721                           const char *rel)
3722 {
3723     char *sep;
3724     /* Absolute path, relative to the current server */
3725     if (base && strstr(base, "://") && rel[0] == '/') {
3726         if (base != buf)
3727             av_strlcpy(buf, base, size);
3728         sep = strstr(buf, "://");
3729         if (sep) {
3730             sep += 3;
3731             sep = strchr(sep, '/');
3732             if (sep)
3733                 *sep = '\0';
3734         }
3735         av_strlcat(buf, rel, size);
3736         return;
3737     }
3738     /* If rel actually is an absolute url, just copy it */
3739     if (!base || strstr(rel, "://") || rel[0] == '/') {
3740         av_strlcpy(buf, rel, size);
3741         return;
3742     }
3743     if (base != buf)
3744         av_strlcpy(buf, base, size);
3745     /* Remove the file name from the base url */
3746     sep = strrchr(buf, '/');
3747     if (sep)
3748         sep[1] = '\0';
3749     else
3750         buf[0] = '\0';
3751     while (av_strstart(rel, "../", NULL) && sep) {
3752         /* Remove the path delimiter at the end */
3753         sep[0] = '\0';
3754         sep = strrchr(buf, '/');
3755         /* If the next directory name to pop off is "..", break here */
3756         if (!strcmp(sep ? &sep[1] : buf, "..")) {
3757             /* Readd the slash we just removed */
3758             av_strlcat(buf, "/", size);
3759             break;
3760         }
3761         /* Cut off the directory name */
3762         if (sep)
3763             sep[1] = '\0';
3764         else
3765             buf[0] = '\0';
3766         rel += 3;
3767     }
3768     av_strlcat(buf, rel, size);
3769 }
3770
3771 int64_t ff_iso8601_to_unix_time(const char *datestr)
3772 {
3773 #if HAVE_STRPTIME
3774     struct tm time1 = {0}, time2 = {0};
3775     char *ret1, *ret2;
3776     ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
3777     ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
3778     if (ret2 && !ret1)
3779         return av_timegm(&time2);
3780     else
3781         return av_timegm(&time1);
3782 #else
3783     av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
3784                                  "the date string.\n");
3785     return 0;
3786 #endif
3787 }
3788
3789 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
3790 {
3791     if (ofmt) {
3792         if (ofmt->query_codec)
3793             return ofmt->query_codec(codec_id, std_compliance);
3794         else if (ofmt->codec_tag)
3795             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
3796         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
3797                  codec_id == ofmt->subtitle_codec)
3798             return 1;
3799     }
3800     return AVERROR_PATCHWELCOME;
3801 }
3802
3803 int avformat_network_init(void)
3804 {
3805 #if CONFIG_NETWORK
3806     int ret;
3807     ff_network_inited_globally = 1;
3808     if ((ret = ff_network_init()) < 0)
3809         return ret;
3810     ff_tls_init();
3811 #endif
3812     return 0;
3813 }
3814
3815 int avformat_network_deinit(void)
3816 {
3817 #if CONFIG_NETWORK
3818     ff_network_close();
3819     ff_tls_deinit();
3820 #endif
3821     return 0;
3822 }
3823
3824 int ff_add_param_change(AVPacket *pkt, int32_t channels,
3825                         uint64_t channel_layout, int32_t sample_rate,
3826                         int32_t width, int32_t height)
3827 {
3828     uint32_t flags = 0;
3829     int size = 4;
3830     uint8_t *data;
3831     if (!pkt)
3832         return AVERROR(EINVAL);
3833     if (channels) {
3834         size += 4;
3835         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
3836     }
3837     if (channel_layout) {
3838         size += 8;
3839         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
3840     }
3841     if (sample_rate) {
3842         size += 4;
3843         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
3844     }
3845     if (width || height) {
3846         size += 8;
3847         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
3848     }
3849     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
3850     if (!data)
3851         return AVERROR(ENOMEM);
3852     bytestream_put_le32(&data, flags);
3853     if (channels)
3854         bytestream_put_le32(&data, channels);
3855     if (channel_layout)
3856         bytestream_put_le64(&data, channel_layout);
3857     if (sample_rate)
3858         bytestream_put_le32(&data, sample_rate);
3859     if (width || height) {
3860         bytestream_put_le32(&data, width);
3861         bytestream_put_le32(&data, height);
3862     }
3863     return 0;
3864 }
3865
3866 const struct AVCodecTag *avformat_get_riff_video_tags(void)
3867 {
3868     return ff_codec_bmp_tags;
3869 }
3870 const struct AVCodecTag *avformat_get_riff_audio_tags(void)
3871 {
3872     return ff_codec_wav_tags;
3873 }