1fea72fc699c1f2a6c36d8a579c2dc0826f0c989
[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 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
502                                AVPacketList **plast_pktl){
503     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
504     if (!pktl)
505         return NULL;
506
507     if (*packet_buffer)
508         (*plast_pktl)->next = pktl;
509     else
510         *packet_buffer = pktl;
511
512     /* add the packet in the buffered packet list */
513     *plast_pktl = pktl;
514     pktl->pkt= *pkt;
515     return &pktl->pkt;
516 }
517
518 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
519 {
520     AVFormatContext *s = *ps;
521     int i, ret = 0;
522     AVDictionary *tmp = NULL;
523     ID3v2ExtraMeta *id3v2_extra_meta = NULL;
524
525     if (!s && !(s = avformat_alloc_context()))
526         return AVERROR(ENOMEM);
527     if (fmt)
528         s->iformat = fmt;
529
530     if (options)
531         av_dict_copy(&tmp, *options, 0);
532
533     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
534         goto fail;
535
536     if ((ret = init_input(s, filename, &tmp)) < 0)
537         goto fail;
538
539     /* check filename in case an image number is expected */
540     if (s->iformat->flags & AVFMT_NEEDNUMBER) {
541         if (!av_filename_number_test(filename)) {
542             ret = AVERROR(EINVAL);
543             goto fail;
544         }
545     }
546
547     s->duration = s->start_time = AV_NOPTS_VALUE;
548     av_strlcpy(s->filename, filename, sizeof(s->filename));
549
550     /* allocate private data */
551     if (s->iformat->priv_data_size > 0) {
552         if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
553             ret = AVERROR(ENOMEM);
554             goto fail;
555         }
556         if (s->iformat->priv_class) {
557             *(const AVClass**)s->priv_data = s->iformat->priv_class;
558             av_opt_set_defaults(s->priv_data);
559             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
560                 goto fail;
561         }
562     }
563
564     /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
565     if (s->pb)
566         ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
567
568     if (s->iformat->read_header)
569         if ((ret = s->iformat->read_header(s)) < 0)
570             goto fail;
571
572     if (id3v2_extra_meta &&
573         (ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
574         goto fail;
575     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
576
577     /* queue attached pictures */
578     for (i = 0; i < s->nb_streams; i++)
579         if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC) {
580             AVPacket copy = s->streams[i]->attached_pic;
581             copy.destruct = NULL;
582             add_to_pktbuf(&s->raw_packet_buffer, &copy, &s->raw_packet_buffer_end);
583         }
584
585     if (s->pb && !s->data_offset)
586         s->data_offset = avio_tell(s->pb);
587
588     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
589
590     if (options) {
591         av_dict_free(options);
592         *options = tmp;
593     }
594     *ps = s;
595     return 0;
596
597 fail:
598     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
599     av_dict_free(&tmp);
600     if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
601         avio_close(s->pb);
602     avformat_free_context(s);
603     *ps = NULL;
604     return ret;
605 }
606
607 /*******************************************************/
608
609 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
610 {
611     int ret, i;
612     AVStream *st;
613
614     for(;;){
615         AVPacketList *pktl = s->raw_packet_buffer;
616
617         if (pktl) {
618             *pkt = pktl->pkt;
619             if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
620                !s->streams[pkt->stream_index]->probe_packets ||
621                s->raw_packet_buffer_remaining_size < pkt->size){
622                 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
623                 av_freep(&pd->buf);
624                 pd->buf_size = 0;
625                 s->raw_packet_buffer = pktl->next;
626                 s->raw_packet_buffer_remaining_size += pkt->size;
627                 av_free(pktl);
628                 return 0;
629             }
630         }
631
632         av_init_packet(pkt);
633         ret= s->iformat->read_packet(s, pkt);
634         if (ret < 0) {
635             if (!pktl || ret == AVERROR(EAGAIN))
636                 return ret;
637             for (i = 0; i < s->nb_streams; i++)
638                 s->streams[i]->probe_packets = 0;
639             continue;
640         }
641
642         if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
643             (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
644             av_log(s, AV_LOG_WARNING,
645                    "Dropped corrupted packet (stream = %d)\n",
646                    pkt->stream_index);
647             av_free_packet(pkt);
648             continue;
649         }
650
651         st= s->streams[pkt->stream_index];
652
653         switch(st->codec->codec_type){
654         case AVMEDIA_TYPE_VIDEO:
655             if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
656             break;
657         case AVMEDIA_TYPE_AUDIO:
658             if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
659             break;
660         case AVMEDIA_TYPE_SUBTITLE:
661             if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
662             break;
663         }
664
665         if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
666                      !st->probe_packets))
667             return ret;
668
669         add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
670         s->raw_packet_buffer_remaining_size -= pkt->size;
671
672         if(st->codec->codec_id == CODEC_ID_PROBE){
673             AVProbeData *pd = &st->probe_data;
674             av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
675             --st->probe_packets;
676
677             pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
678             memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
679             pd->buf_size += pkt->size;
680             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
681
682             if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
683                 //FIXME we do not reduce score to 0 for the case of running out of buffer space in bytes
684                 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
685                 if(st->codec->codec_id != CODEC_ID_PROBE){
686                     pd->buf_size=0;
687                     av_freep(&pd->buf);
688                     av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
689                 }
690             }
691         }
692     }
693 }
694
695 /**********************************************************/
696
697 /**
698  * Get the number of samples of an audio frame. Return -1 on error.
699  */
700 static int get_audio_frame_size(AVCodecContext *enc, int size, int mux)
701 {
702     int frame_size;
703
704     /* give frame_size priority if demuxing */
705     if (!mux && enc->frame_size > 1)
706         return enc->frame_size;
707
708     if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
709         return frame_size;
710
711     /* fallback to using frame_size if muxing */
712     if (enc->frame_size > 1)
713         return enc->frame_size;
714
715     return -1;
716 }
717
718
719 /**
720  * Return the frame duration in seconds. Return 0 if not available.
721  */
722 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
723                                    AVCodecParserContext *pc, AVPacket *pkt)
724 {
725     int frame_size;
726
727     *pnum = 0;
728     *pden = 0;
729     switch(st->codec->codec_type) {
730     case AVMEDIA_TYPE_VIDEO:
731         if (st->r_frame_rate.num) {
732             *pnum = st->r_frame_rate.den;
733             *pden = st->r_frame_rate.num;
734         } else if(st->time_base.num*1000LL > st->time_base.den) {
735             *pnum = st->time_base.num;
736             *pden = st->time_base.den;
737         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
738             *pnum = st->codec->time_base.num;
739             *pden = st->codec->time_base.den;
740             if (pc && pc->repeat_pict) {
741                 *pnum = (*pnum) * (1 + pc->repeat_pict);
742             }
743             //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
744             //Thus if we have no parser in such case leave duration undefined.
745             if(st->codec->ticks_per_frame>1 && !pc){
746                 *pnum = *pden = 0;
747             }
748         }
749         break;
750     case AVMEDIA_TYPE_AUDIO:
751         frame_size = get_audio_frame_size(st->codec, pkt->size, 0);
752         if (frame_size <= 0 || st->codec->sample_rate <= 0)
753             break;
754         *pnum = frame_size;
755         *pden = st->codec->sample_rate;
756         break;
757     default:
758         break;
759     }
760 }
761
762 static int is_intra_only(AVCodecContext *enc){
763     if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
764         return 1;
765     }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
766         switch(enc->codec_id){
767         case CODEC_ID_MJPEG:
768         case CODEC_ID_MJPEGB:
769         case CODEC_ID_LJPEG:
770         case CODEC_ID_PRORES:
771         case CODEC_ID_RAWVIDEO:
772         case CODEC_ID_DVVIDEO:
773         case CODEC_ID_HUFFYUV:
774         case CODEC_ID_FFVHUFF:
775         case CODEC_ID_ASV1:
776         case CODEC_ID_ASV2:
777         case CODEC_ID_VCR1:
778         case CODEC_ID_DNXHD:
779         case CODEC_ID_JPEG2000:
780             return 1;
781         default: break;
782         }
783     }
784     return 0;
785 }
786
787 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
788                                       int64_t dts, int64_t pts)
789 {
790     AVStream *st= s->streams[stream_index];
791     AVPacketList *pktl= s->packet_buffer;
792
793     if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
794         return;
795
796     st->first_dts= dts - st->cur_dts;
797     st->cur_dts= dts;
798
799     for(; pktl; pktl= pktl->next){
800         if(pktl->pkt.stream_index != stream_index)
801             continue;
802         //FIXME think more about this check
803         if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
804             pktl->pkt.pts += st->first_dts;
805
806         if(pktl->pkt.dts != AV_NOPTS_VALUE)
807             pktl->pkt.dts += st->first_dts;
808
809         if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
810             st->start_time= pktl->pkt.pts;
811     }
812     if (st->start_time == AV_NOPTS_VALUE)
813         st->start_time = pts;
814 }
815
816 static void update_initial_durations(AVFormatContext *s, AVStream *st,
817                                      int stream_index, int duration)
818 {
819     AVPacketList *pktl= s->packet_buffer;
820     int64_t cur_dts= 0;
821
822     if(st->first_dts != AV_NOPTS_VALUE){
823         cur_dts= st->first_dts;
824         for(; pktl; pktl= pktl->next){
825             if(pktl->pkt.stream_index == stream_index){
826                 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
827                     break;
828                 cur_dts -= duration;
829             }
830         }
831         pktl= s->packet_buffer;
832         st->first_dts = cur_dts;
833     }else if(st->cur_dts)
834         return;
835
836     for(; pktl; pktl= pktl->next){
837         if(pktl->pkt.stream_index != stream_index)
838             continue;
839         if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
840            && !pktl->pkt.duration){
841             pktl->pkt.dts= cur_dts;
842             if(!st->codec->has_b_frames)
843                 pktl->pkt.pts= cur_dts;
844             cur_dts += duration;
845             if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
846                 pktl->pkt.duration = duration;
847         }else
848             break;
849     }
850     if(st->first_dts == AV_NOPTS_VALUE)
851         st->cur_dts= cur_dts;
852 }
853
854 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
855                                AVCodecParserContext *pc, AVPacket *pkt)
856 {
857     int num, den, presentation_delayed, delay, i;
858     int64_t offset;
859
860     if (s->flags & AVFMT_FLAG_NOFILLIN)
861         return;
862
863     if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
864         pkt->dts= AV_NOPTS_VALUE;
865
866     /* do we have a video B-frame ? */
867     delay= st->codec->has_b_frames;
868     presentation_delayed = 0;
869
870     /* XXX: need has_b_frame, but cannot get it if the codec is
871         not initialized */
872     if (delay &&
873         pc && pc->pict_type != AV_PICTURE_TYPE_B)
874         presentation_delayed = 1;
875
876     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
877        /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
878         pkt->dts -= 1LL<<st->pts_wrap_bits;
879     }
880
881     // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
882     // we take the conservative approach and discard both
883     // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
884     if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
885         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
886         pkt->dts= pkt->pts= AV_NOPTS_VALUE;
887     }
888
889     if (pkt->duration == 0 && st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
890         compute_frame_duration(&num, &den, st, pc, pkt);
891         if (den && num) {
892             pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
893
894             if(pkt->duration != 0 && s->packet_buffer)
895                 update_initial_durations(s, st, pkt->stream_index, pkt->duration);
896         }
897     }
898
899     /* correct timestamps with byte offset if demuxers only have timestamps
900        on packet boundaries */
901     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
902         /* this will estimate bitrate based on this frame's duration and size */
903         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
904         if(pkt->pts != AV_NOPTS_VALUE)
905             pkt->pts += offset;
906         if(pkt->dts != AV_NOPTS_VALUE)
907             pkt->dts += offset;
908     }
909
910     if (pc && pc->dts_sync_point >= 0) {
911         // we have synchronization info from the parser
912         int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
913         if (den > 0) {
914             int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
915             if (pkt->dts != AV_NOPTS_VALUE) {
916                 // got DTS from the stream, update reference timestamp
917                 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
918                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
919             } else if (st->reference_dts != AV_NOPTS_VALUE) {
920                 // compute DTS based on reference timestamp
921                 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
922                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
923             }
924             if (pc->dts_sync_point > 0)
925                 st->reference_dts = pkt->dts; // new reference
926         }
927     }
928
929     /* This may be redundant, but it should not hurt. */
930     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
931         presentation_delayed = 1;
932
933 //    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);
934     /* interpolate PTS and DTS if they are not present */
935     //We skip H264 currently because delay and has_b_frames are not reliably set
936     if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
937         if (presentation_delayed) {
938             /* DTS = decompression timestamp */
939             /* PTS = presentation timestamp */
940             if (pkt->dts == AV_NOPTS_VALUE)
941                 pkt->dts = st->last_IP_pts;
942             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
943             if (pkt->dts == AV_NOPTS_VALUE)
944                 pkt->dts = st->cur_dts;
945
946             /* this is tricky: the dts must be incremented by the duration
947             of the frame we are displaying, i.e. the last I- or P-frame */
948             if (st->last_IP_duration == 0)
949                 st->last_IP_duration = pkt->duration;
950             if(pkt->dts != AV_NOPTS_VALUE)
951                 st->cur_dts = pkt->dts + st->last_IP_duration;
952             st->last_IP_duration  = pkt->duration;
953             st->last_IP_pts= pkt->pts;
954             /* cannot compute PTS if not present (we can compute it only
955             by knowing the future */
956         } else if (pkt->pts != AV_NOPTS_VALUE ||
957                    pkt->dts != AV_NOPTS_VALUE ||
958                    pkt->duration              ||
959                    st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
960             int duration = pkt->duration;
961             if (!duration && st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
962                 compute_frame_duration(&num, &den, st, pc, pkt);
963                 if (den && num) {
964                     duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den,
965                                                  den * (int64_t)st->time_base.num,
966                                                  AV_ROUND_DOWN);
967                     if (duration != 0 && s->packet_buffer) {
968                         update_initial_durations(s, st, pkt->stream_index,
969                                                  duration);
970                     }
971                 }
972             }
973
974             if(pkt->pts != AV_NOPTS_VALUE && duration){
975                 int64_t old_diff= FFABS(st->cur_dts - duration - pkt->pts);
976                 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
977                 if(old_diff < new_diff && old_diff < (duration>>3)){
978                     pkt->pts += duration;
979     //                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);
980                 }
981             }
982
983             /* presentation is not delayed : PTS and DTS are the same */
984             if(pkt->pts == AV_NOPTS_VALUE)
985                 pkt->pts = pkt->dts;
986             update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
987             if(pkt->pts == AV_NOPTS_VALUE)
988                 pkt->pts = st->cur_dts;
989             pkt->dts = pkt->pts;
990             if(pkt->pts != AV_NOPTS_VALUE)
991                 st->cur_dts = pkt->pts + duration;
992         }
993     }
994
995     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
996         st->pts_buffer[0]= pkt->pts;
997         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
998             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
999         if(pkt->dts == AV_NOPTS_VALUE)
1000             pkt->dts= st->pts_buffer[0];
1001         if(st->codec->codec_id == CODEC_ID_H264){ // we skipped it above so we try here
1002             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1003         }
1004         if(pkt->dts > st->cur_dts)
1005             st->cur_dts = pkt->dts;
1006     }
1007
1008 //    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);
1009
1010     /* update flags */
1011     if(is_intra_only(st->codec))
1012         pkt->flags |= AV_PKT_FLAG_KEY;
1013     if (pc)
1014         pkt->convergence_duration = pc->convergence_duration;
1015 }
1016
1017 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1018 {
1019     while (*pkt_buf) {
1020         AVPacketList *pktl = *pkt_buf;
1021         *pkt_buf = pktl->next;
1022         av_free_packet(&pktl->pkt);
1023         av_freep(&pktl);
1024     }
1025     *pkt_buf_end = NULL;
1026 }
1027
1028 /**
1029  * Parse a packet, add all split parts to parse_queue
1030  *
1031  * @param pkt packet to parse, NULL when flushing the parser at end of stream
1032  */
1033 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1034 {
1035     AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1036     AVStream     *st = s->streams[stream_index];
1037     uint8_t    *data = pkt ? pkt->data : NULL;
1038     int         size = pkt ? pkt->size : 0;
1039     int ret = 0, got_output = 0;
1040
1041     if (!pkt) {
1042         av_init_packet(&flush_pkt);
1043         pkt = &flush_pkt;
1044         got_output = 1;
1045     }
1046
1047     while (size > 0 || (pkt == &flush_pkt && got_output)) {
1048         int len;
1049
1050         av_init_packet(&out_pkt);
1051         len = av_parser_parse2(st->parser,  st->codec,
1052                                &out_pkt.data, &out_pkt.size, data, size,
1053                                pkt->pts, pkt->dts, pkt->pos);
1054
1055         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1056         /* increment read pointer */
1057         data += len;
1058         size -= len;
1059
1060         got_output = !!out_pkt.size;
1061
1062         if (!out_pkt.size)
1063             continue;
1064
1065         /* set the duration */
1066         out_pkt.duration = 0;
1067         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1068             if (st->codec->sample_rate > 0) {
1069                 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1070                                                     (AVRational){ 1, st->codec->sample_rate },
1071                                                     st->time_base,
1072                                                     AV_ROUND_DOWN);
1073             }
1074         } else if (st->codec->time_base.num != 0 &&
1075                    st->codec->time_base.den != 0) {
1076             out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1077                                                 st->codec->time_base,
1078                                                 st->time_base,
1079                                                 AV_ROUND_DOWN);
1080         }
1081
1082         out_pkt.stream_index = st->index;
1083         out_pkt.pts = st->parser->pts;
1084         out_pkt.dts = st->parser->dts;
1085         out_pkt.pos = st->parser->pos;
1086
1087         if (st->parser->key_frame == 1 ||
1088             (st->parser->key_frame == -1 &&
1089              st->parser->pict_type == AV_PICTURE_TYPE_I))
1090             out_pkt.flags |= AV_PKT_FLAG_KEY;
1091
1092         compute_pkt_fields(s, st, st->parser, &out_pkt);
1093
1094         if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1095             out_pkt.flags & AV_PKT_FLAG_KEY) {
1096             ff_reduce_index(s, st->index);
1097             av_add_index_entry(st, st->parser->frame_offset, out_pkt.dts,
1098                                0, 0, AVINDEX_KEYFRAME);
1099         }
1100
1101         if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1102             out_pkt.destruct = pkt->destruct;
1103             pkt->destruct = NULL;
1104         }
1105         if ((ret = av_dup_packet(&out_pkt)) < 0)
1106             goto fail;
1107
1108         if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1109             av_free_packet(&out_pkt);
1110             ret = AVERROR(ENOMEM);
1111             goto fail;
1112         }
1113     }
1114
1115
1116     /* end of the stream => close and free the parser */
1117     if (pkt == &flush_pkt) {
1118         av_parser_close(st->parser);
1119         st->parser = NULL;
1120     }
1121
1122 fail:
1123     av_free_packet(pkt);
1124     return ret;
1125 }
1126
1127 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1128                                    AVPacketList **pkt_buffer_end,
1129                                    AVPacket      *pkt)
1130 {
1131     AVPacketList *pktl;
1132     av_assert0(*pkt_buffer);
1133     pktl = *pkt_buffer;
1134     *pkt = pktl->pkt;
1135     *pkt_buffer = pktl->next;
1136     if (!pktl->next)
1137         *pkt_buffer_end = NULL;
1138     av_freep(&pktl);
1139     return 0;
1140 }
1141
1142 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1143 {
1144     int ret = 0, i, got_packet = 0;
1145
1146     av_init_packet(pkt);
1147
1148     while (!got_packet && !s->parse_queue) {
1149         AVStream *st;
1150         AVPacket cur_pkt;
1151
1152         /* read next packet */
1153         ret = av_read_packet(s, &cur_pkt);
1154         if (ret < 0) {
1155             if (ret == AVERROR(EAGAIN))
1156                 return ret;
1157             /* flush the parsers */
1158             for(i = 0; i < s->nb_streams; i++) {
1159                 st = s->streams[i];
1160                 if (st->parser && st->need_parsing)
1161                     parse_packet(s, NULL, st->index);
1162             }
1163             /* all remaining packets are now in parse_queue =>
1164              * really terminate parsing */
1165             break;
1166         }
1167         ret = 0;
1168         st  = s->streams[cur_pkt.stream_index];
1169
1170         if (cur_pkt.pts != AV_NOPTS_VALUE &&
1171             cur_pkt.dts != AV_NOPTS_VALUE &&
1172             cur_pkt.pts < cur_pkt.dts) {
1173             av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1174                    cur_pkt.stream_index,
1175                    cur_pkt.pts,
1176                    cur_pkt.dts,
1177                    cur_pkt.size);
1178         }
1179         if (s->debug & FF_FDEBUG_TS)
1180             av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1181                    cur_pkt.stream_index,
1182                    cur_pkt.pts,
1183                    cur_pkt.dts,
1184                    cur_pkt.size,
1185                    cur_pkt.duration,
1186                    cur_pkt.flags);
1187
1188         if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1189             st->parser = av_parser_init(st->codec->codec_id);
1190             if (!st->parser) {
1191                 /* no parser available: just output the raw packets */
1192                 st->need_parsing = AVSTREAM_PARSE_NONE;
1193             } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1194                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1195             } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1196                 st->parser->flags |= PARSER_FLAG_ONCE;
1197             }
1198         }
1199
1200         if (!st->need_parsing || !st->parser) {
1201             /* no parsing needed: we just output the packet as is */
1202             *pkt = cur_pkt;
1203             compute_pkt_fields(s, st, NULL, pkt);
1204             if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1205                 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1206                 ff_reduce_index(s, st->index);
1207                 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1208             }
1209             got_packet = 1;
1210         } else if (st->discard < AVDISCARD_ALL) {
1211             if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1212                 return ret;
1213         } else {
1214             /* free packet */
1215             av_free_packet(&cur_pkt);
1216         }
1217     }
1218
1219     if (!got_packet && s->parse_queue)
1220         ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1221
1222     if(s->debug & FF_FDEBUG_TS)
1223         av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1224             pkt->stream_index,
1225             pkt->pts,
1226             pkt->dts,
1227             pkt->size,
1228             pkt->duration,
1229             pkt->flags);
1230
1231     return ret;
1232 }
1233
1234 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1235 {
1236     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1237     int          eof = 0;
1238
1239     if (!genpts)
1240         return s->packet_buffer ? read_from_packet_buffer(&s->packet_buffer,
1241                                                           &s->packet_buffer_end,
1242                                                           pkt) :
1243                                   read_frame_internal(s, pkt);
1244
1245     for (;;) {
1246         int ret;
1247         AVPacketList *pktl = s->packet_buffer;
1248
1249         if (pktl) {
1250             AVPacket *next_pkt = &pktl->pkt;
1251
1252             if (next_pkt->dts != AV_NOPTS_VALUE) {
1253                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1254                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1255                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1256                         (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0) &&
1257                          av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1258                         next_pkt->pts = pktl->pkt.dts;
1259                     }
1260                     pktl = pktl->next;
1261                 }
1262                 pktl = s->packet_buffer;
1263             }
1264
1265             /* read packet from packet buffer, if there is data */
1266             if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1267                   next_pkt->dts != AV_NOPTS_VALUE && !eof))
1268                 return read_from_packet_buffer(&s->packet_buffer,
1269                                                &s->packet_buffer_end, pkt);
1270         }
1271
1272         ret = read_frame_internal(s, pkt);
1273         if (ret < 0) {
1274             if (pktl && ret != AVERROR(EAGAIN)) {
1275                 eof = 1;
1276                 continue;
1277             } else
1278                 return ret;
1279         }
1280
1281         if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1282                           &s->packet_buffer_end)) < 0)
1283             return AVERROR(ENOMEM);
1284     }
1285 }
1286
1287 /* XXX: suppress the packet queue */
1288 static void flush_packet_queue(AVFormatContext *s)
1289 {
1290     free_packet_buffer(&s->parse_queue,       &s->parse_queue_end);
1291     free_packet_buffer(&s->packet_buffer,     &s->packet_buffer_end);
1292     free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1293
1294     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1295 }
1296
1297 /*******************************************************/
1298 /* seek support */
1299
1300 int av_find_default_stream_index(AVFormatContext *s)
1301 {
1302     int first_audio_index = -1;
1303     int i;
1304     AVStream *st;
1305
1306     if (s->nb_streams <= 0)
1307         return -1;
1308     for(i = 0; i < s->nb_streams; i++) {
1309         st = s->streams[i];
1310         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1311             !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1312             return i;
1313         }
1314         if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1315             first_audio_index = i;
1316     }
1317     return first_audio_index >= 0 ? first_audio_index : 0;
1318 }
1319
1320 /**
1321  * Flush the frame reader.
1322  */
1323 void ff_read_frame_flush(AVFormatContext *s)
1324 {
1325     AVStream *st;
1326     int i, j;
1327
1328     flush_packet_queue(s);
1329
1330     /* for each stream, reset read state */
1331     for(i = 0; i < s->nb_streams; i++) {
1332         st = s->streams[i];
1333
1334         if (st->parser) {
1335             av_parser_close(st->parser);
1336             st->parser = NULL;
1337         }
1338         st->last_IP_pts = AV_NOPTS_VALUE;
1339         st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1340         st->reference_dts = AV_NOPTS_VALUE;
1341
1342         st->probe_packets = MAX_PROBE_PACKETS;
1343
1344         for(j=0; j<MAX_REORDER_DELAY+1; j++)
1345             st->pts_buffer[j]= AV_NOPTS_VALUE;
1346     }
1347 }
1348
1349 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1350 {
1351     int i;
1352
1353     for(i = 0; i < s->nb_streams; i++) {
1354         AVStream *st = s->streams[i];
1355
1356         st->cur_dts = av_rescale(timestamp,
1357                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1358                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1359     }
1360 }
1361
1362 void ff_reduce_index(AVFormatContext *s, int stream_index)
1363 {
1364     AVStream *st= s->streams[stream_index];
1365     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1366
1367     if((unsigned)st->nb_index_entries >= max_entries){
1368         int i;
1369         for(i=0; 2*i<st->nb_index_entries; i++)
1370             st->index_entries[i]= st->index_entries[2*i];
1371         st->nb_index_entries= i;
1372     }
1373 }
1374
1375 int ff_add_index_entry(AVIndexEntry **index_entries,
1376                        int *nb_index_entries,
1377                        unsigned int *index_entries_allocated_size,
1378                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1379 {
1380     AVIndexEntry *entries, *ie;
1381     int index;
1382
1383     if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1384         return -1;
1385
1386     entries = av_fast_realloc(*index_entries,
1387                               index_entries_allocated_size,
1388                               (*nb_index_entries + 1) *
1389                               sizeof(AVIndexEntry));
1390     if(!entries)
1391         return -1;
1392
1393     *index_entries= entries;
1394
1395     index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1396
1397     if(index<0){
1398         index= (*nb_index_entries)++;
1399         ie= &entries[index];
1400         assert(index==0 || ie[-1].timestamp < timestamp);
1401     }else{
1402         ie= &entries[index];
1403         if(ie->timestamp != timestamp){
1404             if(ie->timestamp <= timestamp)
1405                 return -1;
1406             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1407             (*nb_index_entries)++;
1408         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1409             distance= ie->min_distance;
1410     }
1411
1412     ie->pos = pos;
1413     ie->timestamp = timestamp;
1414     ie->min_distance= distance;
1415     ie->size= size;
1416     ie->flags = flags;
1417
1418     return index;
1419 }
1420
1421 int av_add_index_entry(AVStream *st,
1422                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1423 {
1424     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1425                               &st->index_entries_allocated_size, pos,
1426                               timestamp, size, distance, flags);
1427 }
1428
1429 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1430                               int64_t wanted_timestamp, int flags)
1431 {
1432     int a, b, m;
1433     int64_t timestamp;
1434
1435     a = - 1;
1436     b = nb_entries;
1437
1438     //optimize appending index entries at the end
1439     if(b && entries[b-1].timestamp < wanted_timestamp)
1440         a= b-1;
1441
1442     while (b - a > 1) {
1443         m = (a + b) >> 1;
1444         timestamp = entries[m].timestamp;
1445         if(timestamp >= wanted_timestamp)
1446             b = m;
1447         if(timestamp <= wanted_timestamp)
1448             a = m;
1449     }
1450     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1451
1452     if(!(flags & AVSEEK_FLAG_ANY)){
1453         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1454             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1455         }
1456     }
1457
1458     if(m == nb_entries)
1459         return -1;
1460     return  m;
1461 }
1462
1463 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1464                               int flags)
1465 {
1466     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1467                                      wanted_timestamp, flags);
1468 }
1469
1470 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1471 {
1472     AVInputFormat *avif= s->iformat;
1473     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1474     int64_t ts_min, ts_max, ts;
1475     int index;
1476     int64_t ret;
1477     AVStream *st;
1478
1479     if (stream_index < 0)
1480         return -1;
1481
1482     av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1483
1484     ts_max=
1485     ts_min= AV_NOPTS_VALUE;
1486     pos_limit= -1; //gcc falsely says it may be uninitialized
1487
1488     st= s->streams[stream_index];
1489     if(st->index_entries){
1490         AVIndexEntry *e;
1491
1492         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()
1493         index= FFMAX(index, 0);
1494         e= &st->index_entries[index];
1495
1496         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1497             pos_min= e->pos;
1498             ts_min= e->timestamp;
1499             av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1500                     pos_min,ts_min);
1501         }else{
1502             assert(index==0);
1503         }
1504
1505         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1506         assert(index < st->nb_index_entries);
1507         if(index >= 0){
1508             e= &st->index_entries[index];
1509             assert(e->timestamp >= target_ts);
1510             pos_max= e->pos;
1511             ts_max= e->timestamp;
1512             pos_limit= pos_max - e->min_distance;
1513             av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1514                     pos_max,pos_limit, ts_max);
1515         }
1516     }
1517
1518     pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1519     if(pos<0)
1520         return -1;
1521
1522     /* do the seek */
1523     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1524         return ret;
1525
1526     ff_update_cur_dts(s, st, ts);
1527
1528     return 0;
1529 }
1530
1531 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1532                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1533                       int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1534                       int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1535 {
1536     int64_t pos, ts;
1537     int64_t start_pos, filesize;
1538     int no_change;
1539
1540     av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1541
1542     if(ts_min == AV_NOPTS_VALUE){
1543         pos_min = s->data_offset;
1544         ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1545         if (ts_min == AV_NOPTS_VALUE)
1546             return -1;
1547     }
1548
1549     if(ts_max == AV_NOPTS_VALUE){
1550         int step= 1024;
1551         filesize = avio_size(s->pb);
1552         pos_max = filesize - 1;
1553         do{
1554             pos_max -= step;
1555             ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1556             step += step;
1557         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1558         if (ts_max == AV_NOPTS_VALUE)
1559             return -1;
1560
1561         for(;;){
1562             int64_t tmp_pos= pos_max + 1;
1563             int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1564             if(tmp_ts == AV_NOPTS_VALUE)
1565                 break;
1566             ts_max= tmp_ts;
1567             pos_max= tmp_pos;
1568             if(tmp_pos >= filesize)
1569                 break;
1570         }
1571         pos_limit= pos_max;
1572     }
1573
1574     if(ts_min > ts_max){
1575         return -1;
1576     }else if(ts_min == ts_max){
1577         pos_limit= pos_min;
1578     }
1579
1580     no_change=0;
1581     while (pos_min < pos_limit) {
1582         av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1583                 pos_min, pos_max, ts_min, ts_max);
1584         assert(pos_limit <= pos_max);
1585
1586         if(no_change==0){
1587             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1588             // interpolate position (better than dichotomy)
1589             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1590                 + pos_min - approximate_keyframe_distance;
1591         }else if(no_change==1){
1592             // bisection, if interpolation failed to change min or max pos last time
1593             pos = (pos_min + pos_limit)>>1;
1594         }else{
1595             /* linear search if bisection failed, can only happen if there
1596                are very few or no keyframes between min/max */
1597             pos=pos_min;
1598         }
1599         if(pos <= pos_min)
1600             pos= pos_min + 1;
1601         else if(pos > pos_limit)
1602             pos= pos_limit;
1603         start_pos= pos;
1604
1605         ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1606         if(pos == pos_max)
1607             no_change++;
1608         else
1609             no_change=0;
1610         av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1611                 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1612                 pos_limit, start_pos, no_change);
1613         if(ts == AV_NOPTS_VALUE){
1614             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1615             return -1;
1616         }
1617         assert(ts != AV_NOPTS_VALUE);
1618         if (target_ts <= ts) {
1619             pos_limit = start_pos - 1;
1620             pos_max = pos;
1621             ts_max = ts;
1622         }
1623         if (target_ts >= ts) {
1624             pos_min = pos;
1625             ts_min = ts;
1626         }
1627     }
1628
1629     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1630     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1631     pos_min = pos;
1632     ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1633     pos_min++;
1634     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1635     av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1636             pos, ts_min, target_ts, ts_max);
1637     *ts_ret= ts;
1638     return pos;
1639 }
1640
1641 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1642     int64_t pos_min, pos_max;
1643 #if 0
1644     AVStream *st;
1645
1646     if (stream_index < 0)
1647         return -1;
1648
1649     st= s->streams[stream_index];
1650 #endif
1651
1652     pos_min = s->data_offset;
1653     pos_max = avio_size(s->pb) - 1;
1654
1655     if     (pos < pos_min) pos= pos_min;
1656     else if(pos > pos_max) pos= pos_max;
1657
1658     avio_seek(s->pb, pos, SEEK_SET);
1659
1660 #if 0
1661     av_update_cur_dts(s, st, ts);
1662 #endif
1663     return 0;
1664 }
1665
1666 static int seek_frame_generic(AVFormatContext *s,
1667                                  int stream_index, int64_t timestamp, int flags)
1668 {
1669     int index;
1670     int64_t ret;
1671     AVStream *st;
1672     AVIndexEntry *ie;
1673
1674     st = s->streams[stream_index];
1675
1676     index = av_index_search_timestamp(st, timestamp, flags);
1677
1678     if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1679         return -1;
1680
1681     if(index < 0 || index==st->nb_index_entries-1){
1682         AVPacket pkt;
1683
1684         if(st->nb_index_entries){
1685             assert(st->index_entries);
1686             ie= &st->index_entries[st->nb_index_entries-1];
1687             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1688                 return ret;
1689             ff_update_cur_dts(s, st, ie->timestamp);
1690         }else{
1691             if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1692                 return ret;
1693         }
1694         for (;;) {
1695             int read_status;
1696             do{
1697                 read_status = av_read_frame(s, &pkt);
1698             } while (read_status == AVERROR(EAGAIN));
1699             if (read_status < 0)
1700                 break;
1701             av_free_packet(&pkt);
1702             if(stream_index == pkt.stream_index){
1703                 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1704                     break;
1705             }
1706         }
1707         index = av_index_search_timestamp(st, timestamp, flags);
1708     }
1709     if (index < 0)
1710         return -1;
1711
1712     ff_read_frame_flush(s);
1713     if (s->iformat->read_seek){
1714         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1715             return 0;
1716     }
1717     ie = &st->index_entries[index];
1718     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1719         return ret;
1720     ff_update_cur_dts(s, st, ie->timestamp);
1721
1722     return 0;
1723 }
1724
1725 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1726 {
1727     int ret;
1728     AVStream *st;
1729
1730     if (flags & AVSEEK_FLAG_BYTE) {
1731         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1732             return -1;
1733         ff_read_frame_flush(s);
1734         return seek_frame_byte(s, stream_index, timestamp, flags);
1735     }
1736
1737     if(stream_index < 0){
1738         stream_index= av_find_default_stream_index(s);
1739         if(stream_index < 0)
1740             return -1;
1741
1742         st= s->streams[stream_index];
1743         /* timestamp for default must be expressed in AV_TIME_BASE units */
1744         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1745     }
1746
1747     /* first, we try the format specific seek */
1748     if (s->iformat->read_seek) {
1749         ff_read_frame_flush(s);
1750         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1751     } else
1752         ret = -1;
1753     if (ret >= 0) {
1754         return 0;
1755     }
1756
1757     if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1758         ff_read_frame_flush(s);
1759         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1760     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1761         ff_read_frame_flush(s);
1762         return seek_frame_generic(s, stream_index, timestamp, flags);
1763     }
1764     else
1765         return -1;
1766 }
1767
1768 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1769 {
1770     if(min_ts > ts || max_ts < ts)
1771         return -1;
1772
1773     if (s->iformat->read_seek2) {
1774         ff_read_frame_flush(s);
1775         return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1776     }
1777
1778     if(s->iformat->read_timestamp){
1779         //try to seek via read_timestamp()
1780     }
1781
1782     //Fallback to old API if new is not implemented but old is
1783     //Note the old has somewat different sematics
1784     if(s->iformat->read_seek || 1)
1785         return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1786
1787     // try some generic seek like seek_frame_generic() but with new ts semantics
1788 }
1789
1790 /*******************************************************/
1791
1792 /**
1793  * Return TRUE if the stream has accurate duration in any stream.
1794  *
1795  * @return TRUE if the stream has accurate duration for at least one component.
1796  */
1797 static int has_duration(AVFormatContext *ic)
1798 {
1799     int i;
1800     AVStream *st;
1801
1802     for(i = 0;i < ic->nb_streams; i++) {
1803         st = ic->streams[i];
1804         if (st->duration != AV_NOPTS_VALUE)
1805             return 1;
1806     }
1807     return 0;
1808 }
1809
1810 /**
1811  * Estimate the stream timings from the one of each components.
1812  *
1813  * Also computes the global bitrate if possible.
1814  */
1815 static void update_stream_timings(AVFormatContext *ic)
1816 {
1817     int64_t start_time, start_time1, end_time, end_time1;
1818     int64_t duration, duration1, filesize;
1819     int i;
1820     AVStream *st;
1821
1822     start_time = INT64_MAX;
1823     end_time = INT64_MIN;
1824     duration = INT64_MIN;
1825     for(i = 0;i < ic->nb_streams; i++) {
1826         st = ic->streams[i];
1827         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1828             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1829             start_time = FFMIN(start_time, start_time1);
1830             if (st->duration != AV_NOPTS_VALUE) {
1831                 end_time1 = start_time1
1832                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1833                 end_time = FFMAX(end_time, end_time1);
1834             }
1835         }
1836         if (st->duration != AV_NOPTS_VALUE) {
1837             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1838             duration = FFMAX(duration, duration1);
1839         }
1840     }
1841     if (start_time != INT64_MAX) {
1842         ic->start_time = start_time;
1843         if (end_time != INT64_MIN)
1844             duration = FFMAX(duration, end_time - start_time);
1845     }
1846     if (duration != INT64_MIN) {
1847         ic->duration = duration;
1848         if (ic->pb && (filesize = avio_size(ic->pb)) > 0) {
1849             /* compute the bitrate */
1850             ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
1851                 (double)ic->duration;
1852         }
1853     }
1854 }
1855
1856 static void fill_all_stream_timings(AVFormatContext *ic)
1857 {
1858     int i;
1859     AVStream *st;
1860
1861     update_stream_timings(ic);
1862     for(i = 0;i < ic->nb_streams; i++) {
1863         st = ic->streams[i];
1864         if (st->start_time == AV_NOPTS_VALUE) {
1865             if(ic->start_time != AV_NOPTS_VALUE)
1866                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1867             if(ic->duration != AV_NOPTS_VALUE)
1868                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1869         }
1870     }
1871 }
1872
1873 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1874 {
1875     int64_t filesize, duration;
1876     int bit_rate, i;
1877     AVStream *st;
1878
1879     /* if bit_rate is already set, we believe it */
1880     if (ic->bit_rate <= 0) {
1881         bit_rate = 0;
1882         for(i=0;i<ic->nb_streams;i++) {
1883             st = ic->streams[i];
1884             if (st->codec->bit_rate > 0)
1885             bit_rate += st->codec->bit_rate;
1886         }
1887         ic->bit_rate = bit_rate;
1888     }
1889
1890     /* if duration is already set, we believe it */
1891     if (ic->duration == AV_NOPTS_VALUE &&
1892         ic->bit_rate != 0) {
1893         filesize = ic->pb ? avio_size(ic->pb) : 0;
1894         if (filesize > 0) {
1895             for(i = 0; i < ic->nb_streams; i++) {
1896                 st = ic->streams[i];
1897                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1898                 if (st->duration == AV_NOPTS_VALUE)
1899                     st->duration = duration;
1900             }
1901         }
1902     }
1903 }
1904
1905 #define DURATION_MAX_READ_SIZE 250000
1906 #define DURATION_MAX_RETRY 3
1907
1908 /* only usable for MPEG-PS streams */
1909 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1910 {
1911     AVPacket pkt1, *pkt = &pkt1;
1912     AVStream *st;
1913     int read_size, i, ret;
1914     int64_t end_time;
1915     int64_t filesize, offset, duration;
1916     int retry=0;
1917
1918     /* flush packet queue */
1919     flush_packet_queue(ic);
1920
1921     for (i=0; i<ic->nb_streams; i++) {
1922         st = ic->streams[i];
1923         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1924             av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
1925
1926         if (st->parser) {
1927             av_parser_close(st->parser);
1928             st->parser= NULL;
1929         }
1930     }
1931
1932     /* estimate the end time (duration) */
1933     /* XXX: may need to support wrapping */
1934     filesize = ic->pb ? avio_size(ic->pb) : 0;
1935     end_time = AV_NOPTS_VALUE;
1936     do{
1937         offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1938         if (offset < 0)
1939             offset = 0;
1940
1941         avio_seek(ic->pb, offset, SEEK_SET);
1942         read_size = 0;
1943         for(;;) {
1944             if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1945                 break;
1946
1947             do {
1948                 ret = av_read_packet(ic, pkt);
1949             } while(ret == AVERROR(EAGAIN));
1950             if (ret != 0)
1951                 break;
1952             read_size += pkt->size;
1953             st = ic->streams[pkt->stream_index];
1954             if (pkt->pts != AV_NOPTS_VALUE &&
1955                 (st->start_time != AV_NOPTS_VALUE ||
1956                  st->first_dts  != AV_NOPTS_VALUE)) {
1957                 duration = end_time = pkt->pts;
1958                 if (st->start_time != AV_NOPTS_VALUE)
1959                     duration -= st->start_time;
1960                 else
1961                     duration -= st->first_dts;
1962                 if (duration < 0)
1963                     duration += 1LL<<st->pts_wrap_bits;
1964                 if (duration > 0) {
1965                     if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
1966                         st->duration = duration;
1967                 }
1968             }
1969             av_free_packet(pkt);
1970         }
1971     }while(   end_time==AV_NOPTS_VALUE
1972            && filesize > (DURATION_MAX_READ_SIZE<<retry)
1973            && ++retry <= DURATION_MAX_RETRY);
1974
1975     fill_all_stream_timings(ic);
1976
1977     avio_seek(ic->pb, old_offset, SEEK_SET);
1978     for (i=0; i<ic->nb_streams; i++) {
1979         st= ic->streams[i];
1980         st->cur_dts= st->first_dts;
1981         st->last_IP_pts = AV_NOPTS_VALUE;
1982         st->reference_dts = AV_NOPTS_VALUE;
1983     }
1984 }
1985
1986 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
1987 {
1988     int64_t file_size;
1989
1990     /* get the file size, if possible */
1991     if (ic->iformat->flags & AVFMT_NOFILE) {
1992         file_size = 0;
1993     } else {
1994         file_size = avio_size(ic->pb);
1995         file_size = FFMAX(0, file_size);
1996     }
1997
1998     if ((!strcmp(ic->iformat->name, "mpeg") ||
1999          !strcmp(ic->iformat->name, "mpegts")) &&
2000         file_size && ic->pb->seekable) {
2001         /* get accurate estimate from the PTSes */
2002         estimate_timings_from_pts(ic, old_offset);
2003     } else if (has_duration(ic)) {
2004         /* at least one component has timings - we use them for all
2005            the components */
2006         fill_all_stream_timings(ic);
2007     } else {
2008         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2009         /* less precise: use bitrate info */
2010         estimate_timings_from_bit_rate(ic);
2011     }
2012     update_stream_timings(ic);
2013
2014     {
2015         int i;
2016         AVStream av_unused *st;
2017         for(i = 0;i < ic->nb_streams; i++) {
2018             st = ic->streams[i];
2019             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2020                     (double) st->start_time / AV_TIME_BASE,
2021                     (double) st->duration   / AV_TIME_BASE);
2022         }
2023         av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2024                 (double) ic->start_time / AV_TIME_BASE,
2025                 (double) ic->duration   / AV_TIME_BASE,
2026                 ic->bit_rate / 1000);
2027     }
2028 }
2029
2030 static int has_codec_parameters(AVStream *st)
2031 {
2032     AVCodecContext *avctx = st->codec;
2033     int val;
2034     switch (avctx->codec_type) {
2035     case AVMEDIA_TYPE_AUDIO:
2036         val = avctx->sample_rate && avctx->channels;
2037         if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2038             return 0;
2039         break;
2040     case AVMEDIA_TYPE_VIDEO:
2041         val = avctx->width;
2042         if (st->info->found_decoder >= 0 && avctx->pix_fmt == PIX_FMT_NONE)
2043             return 0;
2044         break;
2045     default:
2046         val = 1;
2047         break;
2048     }
2049     return avctx->codec_id != CODEC_ID_NONE && val != 0;
2050 }
2051
2052 static int has_decode_delay_been_guessed(AVStream *st)
2053 {
2054     return st->codec->codec_id != CODEC_ID_H264 ||
2055         st->info->nb_decoded_frames >= 6;
2056 }
2057
2058 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2059 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2060 {
2061     AVCodec *codec;
2062     int got_picture = 1, ret = 0;
2063     AVFrame picture;
2064     AVPacket pkt = *avpkt;
2065
2066     if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2067         AVDictionary *thread_opt = NULL;
2068
2069         codec = st->codec->codec ? st->codec->codec :
2070                                    avcodec_find_decoder(st->codec->codec_id);
2071
2072         if (!codec) {
2073             st->info->found_decoder = -1;
2074             return -1;
2075         }
2076
2077         /* force thread count to 1 since the h264 decoder will not extract SPS
2078          *  and PPS to extradata during multi-threaded decoding */
2079         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2080         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2081         if (!options)
2082             av_dict_free(&thread_opt);
2083         if (ret < 0) {
2084             st->info->found_decoder = -1;
2085             return ret;
2086         }
2087         st->info->found_decoder = 1;
2088     } else if (!st->info->found_decoder)
2089         st->info->found_decoder = 1;
2090
2091     if (st->info->found_decoder < 0)
2092         return -1;
2093
2094     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2095            ret >= 0 &&
2096            (!has_codec_parameters(st)         ||
2097            !has_decode_delay_been_guessed(st) ||
2098            (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2099         got_picture = 0;
2100         avcodec_get_frame_defaults(&picture);
2101         switch(st->codec->codec_type) {
2102         case AVMEDIA_TYPE_VIDEO:
2103             ret = avcodec_decode_video2(st->codec, &picture,
2104                                         &got_picture, &pkt);
2105             break;
2106         case AVMEDIA_TYPE_AUDIO:
2107             ret = avcodec_decode_audio4(st->codec, &picture, &got_picture, &pkt);
2108             break;
2109         default:
2110             break;
2111         }
2112         if (ret >= 0) {
2113             if (got_picture)
2114                 st->info->nb_decoded_frames++;
2115             pkt.data += ret;
2116             pkt.size -= ret;
2117             ret       = got_picture;
2118         }
2119     }
2120     return ret;
2121 }
2122
2123 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2124 {
2125     while (tags->id != CODEC_ID_NONE) {
2126         if (tags->id == id)
2127             return tags->tag;
2128         tags++;
2129     }
2130     return 0;
2131 }
2132
2133 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2134 {
2135     int i;
2136     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2137         if(tag == tags[i].tag)
2138             return tags[i].id;
2139     }
2140     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2141         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2142             return tags[i].id;
2143     }
2144     return CODEC_ID_NONE;
2145 }
2146
2147 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2148 {
2149     int i;
2150     for(i=0; tags && tags[i]; i++){
2151         int tag= ff_codec_get_tag(tags[i], id);
2152         if(tag) return tag;
2153     }
2154     return 0;
2155 }
2156
2157 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2158 {
2159     int i;
2160     for(i=0; tags && tags[i]; i++){
2161         enum CodecID id= ff_codec_get_id(tags[i], tag);
2162         if(id!=CODEC_ID_NONE) return id;
2163     }
2164     return CODEC_ID_NONE;
2165 }
2166
2167 static void compute_chapters_end(AVFormatContext *s)
2168 {
2169     unsigned int i, j;
2170     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2171
2172     for (i = 0; i < s->nb_chapters; i++)
2173         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2174             AVChapter *ch = s->chapters[i];
2175             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2176                                      : INT64_MAX;
2177
2178             for (j = 0; j < s->nb_chapters; j++) {
2179                 AVChapter *ch1 = s->chapters[j];
2180                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2181                 if (j != i && next_start > ch->start && next_start < end)
2182                     end = next_start;
2183             }
2184             ch->end = (end == INT64_MAX) ? ch->start : end;
2185         }
2186 }
2187
2188 static int get_std_framerate(int i){
2189     if(i<60*12) return i*1001;
2190     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2191 }
2192
2193 /*
2194  * Is the time base unreliable.
2195  * This is a heuristic to balance between quick acceptance of the values in
2196  * the headers vs. some extra checks.
2197  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2198  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2199  * And there are "variable" fps files this needs to detect as well.
2200  */
2201 static int tb_unreliable(AVCodecContext *c){
2202     if(   c->time_base.den >= 101L*c->time_base.num
2203        || c->time_base.den <    5L*c->time_base.num
2204 /*       || c->codec_tag == AV_RL32("DIVX")
2205        || c->codec_tag == AV_RL32("XVID")*/
2206        || c->codec_id == CODEC_ID_MPEG2VIDEO
2207        || c->codec_id == CODEC_ID_H264
2208        )
2209         return 1;
2210     return 0;
2211 }
2212
2213 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2214 {
2215     int i, count, ret, read_size, j;
2216     AVStream *st;
2217     AVPacket pkt1, *pkt;
2218     int64_t old_offset = avio_tell(ic->pb);
2219     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2220
2221     for(i=0;i<ic->nb_streams;i++) {
2222         AVCodec *codec;
2223         AVDictionary *thread_opt = NULL;
2224         st = ic->streams[i];
2225
2226         //only for the split stuff
2227         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2228             st->parser = av_parser_init(st->codec->codec_id);
2229             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2230                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2231             }
2232         }
2233         codec = st->codec->codec ? st->codec->codec :
2234                                    avcodec_find_decoder(st->codec->codec_id);
2235
2236         /* force thread count to 1 since the h264 decoder will not extract SPS
2237          *  and PPS to extradata during multi-threaded decoding */
2238         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2239
2240         /* Ensure that subtitle_header is properly set. */
2241         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2242             && codec && !st->codec->codec)
2243             avcodec_open2(st->codec, codec, options ? &options[i]
2244                               : &thread_opt);
2245
2246         //try to just open decoders, in case this is enough to get parameters
2247         if (!has_codec_parameters(st)) {
2248             if (codec && !st->codec->codec)
2249                 avcodec_open2(st->codec, codec, options ? &options[i]
2250                               : &thread_opt);
2251         }
2252         if (!options)
2253             av_dict_free(&thread_opt);
2254     }
2255
2256     for (i=0; i<ic->nb_streams; i++) {
2257         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2258     }
2259
2260     count = 0;
2261     read_size = 0;
2262     for(;;) {
2263         if (ff_check_interrupt(&ic->interrupt_callback)){
2264             ret= AVERROR_EXIT;
2265             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2266             break;
2267         }
2268
2269         /* check if one codec still needs to be handled */
2270         for(i=0;i<ic->nb_streams;i++) {
2271             int fps_analyze_framecount = 20;
2272
2273             st = ic->streams[i];
2274             if (!has_codec_parameters(st))
2275                 break;
2276             /* if the timebase is coarse (like the usual millisecond precision
2277                of mkv), we need to analyze more frames to reliably arrive at
2278                the correct fps */
2279             if (av_q2d(st->time_base) > 0.0005)
2280                 fps_analyze_framecount *= 2;
2281             if (ic->fps_probe_size >= 0)
2282                 fps_analyze_framecount = ic->fps_probe_size;
2283             /* variable fps and no guess at the real fps */
2284             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2285                && st->info->duration_count < fps_analyze_framecount
2286                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2287                 break;
2288             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2289                 break;
2290             if(st->first_dts == AV_NOPTS_VALUE)
2291                 break;
2292         }
2293         if (i == ic->nb_streams) {
2294             /* NOTE: if the format has no header, then we need to read
2295                some packets to get most of the streams, so we cannot
2296                stop here */
2297             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2298                 /* if we found the info for all the codecs, we can stop */
2299                 ret = count;
2300                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2301                 break;
2302             }
2303         }
2304         /* we did not get all the codec info, but we read too much data */
2305         if (read_size >= ic->probesize) {
2306             ret = count;
2307             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2308             break;
2309         }
2310
2311         /* NOTE: a new stream can be added there if no header in file
2312            (AVFMTCTX_NOHEADER) */
2313         ret = read_frame_internal(ic, &pkt1);
2314         if (ret == AVERROR(EAGAIN))
2315             continue;
2316
2317         if (ret < 0) {
2318             /* EOF or error*/
2319             AVPacket empty_pkt = { 0 };
2320             int err = 0;
2321             av_init_packet(&empty_pkt);
2322
2323             ret = -1; /* we could not have all the codec parameters before EOF */
2324             for(i=0;i<ic->nb_streams;i++) {
2325                 st = ic->streams[i];
2326
2327                 /* flush the decoders */
2328                 if (st->info->found_decoder == 1) {
2329                     do {
2330                         err = try_decode_frame(st, &empty_pkt,
2331                                                (options && i < orig_nb_streams) ?
2332                                                &options[i] : NULL);
2333                     } while (err > 0 && !has_codec_parameters(st));
2334                 }
2335
2336                 if (err < 0) {
2337                     av_log(ic, AV_LOG_WARNING,
2338                            "decoding for stream %d failed\n", st->index);
2339                 } else if (!has_codec_parameters(st)) {
2340                     char buf[256];
2341                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2342                     av_log(ic, AV_LOG_WARNING,
2343                            "Could not find codec parameters (%s)\n", buf);
2344                 } else {
2345                     ret = 0;
2346                 }
2347             }
2348             break;
2349         }
2350
2351         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2352         if ((ret = av_dup_packet(pkt)) < 0)
2353             goto find_stream_info_err;
2354
2355         read_size += pkt->size;
2356
2357         st = ic->streams[pkt->stream_index];
2358         if (st->codec_info_nb_frames>1) {
2359             if (av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2360                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2361                 break;
2362             }
2363             st->info->codec_info_duration += pkt->duration;
2364         }
2365         {
2366             int64_t last = st->info->last_dts;
2367
2368             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
2369                 int64_t duration= pkt->dts - last;
2370                 double dur= duration * av_q2d(st->time_base);
2371
2372 //                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2373 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2374                 if (st->info->duration_count < 2)
2375                     memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2376                 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2377                     int framerate= get_std_framerate(i);
2378                     int ticks= lrintf(dur*framerate/(1001*12));
2379                     double error = dur - (double)ticks*1001*12 / framerate;
2380                     st->info->duration_error[i] += error*error;
2381                 }
2382                 st->info->duration_count++;
2383                 // ignore the first 4 values, they might have some random jitter
2384                 if (st->info->duration_count > 3)
2385                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2386             }
2387             if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2388                 st->info->last_dts = pkt->dts;
2389         }
2390         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2391             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2392             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2393                 st->codec->extradata_size= i;
2394                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2395                 if (!st->codec->extradata)
2396                     return AVERROR(ENOMEM);
2397                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2398                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2399             }
2400         }
2401
2402         /* if still no information, we try to open the codec and to
2403            decompress the frame. We try to avoid that in most cases as
2404            it takes longer and uses more memory. For MPEG-4, we need to
2405            decompress for QuickTime.
2406
2407            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2408            least one frame of codec data, this makes sure the codec initializes
2409            the channel configuration and does not only trust the values from the container.
2410         */
2411         try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2412
2413         st->codec_info_nb_frames++;
2414         count++;
2415     }
2416
2417     // close codecs which were opened in try_decode_frame()
2418     for(i=0;i<ic->nb_streams;i++) {
2419         st = ic->streams[i];
2420         avcodec_close(st->codec);
2421     }
2422     for(i=0;i<ic->nb_streams;i++) {
2423         st = ic->streams[i];
2424         if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2425             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2426                      (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2427                       st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2428         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2429             // the check for tb_unreliable() is not completely correct, since this is not about handling
2430             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2431             // ipmovie.c produces.
2432             if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2433                 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);
2434             if (st->info->duration_count && !st->r_frame_rate.num
2435                && tb_unreliable(st->codec) /*&&
2436                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2437                st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2438                 int num = 0;
2439                 double best_error= 2*av_q2d(st->time_base);
2440                 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2441
2442                 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2443                     double error = st->info->duration_error[j] * get_std_framerate(j);
2444 //                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2445 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2446                     if(error < best_error){
2447                         best_error= error;
2448                         num = get_std_framerate(j);
2449                     }
2450                 }
2451                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2452                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2453                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2454             }
2455         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2456             if(!st->codec->bits_per_coded_sample)
2457                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2458             // set stream disposition based on audio service type
2459             switch (st->codec->audio_service_type) {
2460             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2461                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2462             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2463                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2464             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2465                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2466             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2467                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2468             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2469                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2470             }
2471         }
2472     }
2473
2474     estimate_timings(ic, old_offset);
2475
2476     compute_chapters_end(ic);
2477
2478 #if 0
2479     /* correct DTS for B-frame streams with no timestamps */
2480     for(i=0;i<ic->nb_streams;i++) {
2481         st = ic->streams[i];
2482         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2483             if(b-frames){
2484                 ppktl = &ic->packet_buffer;
2485                 while(ppkt1){
2486                     if(ppkt1->stream_index != i)
2487                         continue;
2488                     if(ppkt1->pkt->dts < 0)
2489                         break;
2490                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2491                         break;
2492                     ppkt1->pkt->dts -= delta;
2493                     ppkt1= ppkt1->next;
2494                 }
2495                 if(ppkt1)
2496                     continue;
2497                 st->cur_dts -= delta;
2498             }
2499         }
2500     }
2501 #endif
2502
2503  find_stream_info_err:
2504     for (i=0; i < ic->nb_streams; i++) {
2505         if (ic->streams[i]->codec)
2506             ic->streams[i]->codec->thread_count = 0;
2507         av_freep(&ic->streams[i]->info);
2508     }
2509     return ret;
2510 }
2511
2512 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2513 {
2514     int i, j;
2515
2516     for (i = 0; i < ic->nb_programs; i++)
2517         for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2518             if (ic->programs[i]->stream_index[j] == s)
2519                 return ic->programs[i];
2520     return NULL;
2521 }
2522
2523 int av_find_best_stream(AVFormatContext *ic,
2524                         enum AVMediaType type,
2525                         int wanted_stream_nb,
2526                         int related_stream,
2527                         AVCodec **decoder_ret,
2528                         int flags)
2529 {
2530     int i, nb_streams = ic->nb_streams;
2531     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2532     unsigned *program = NULL;
2533     AVCodec *decoder = NULL, *best_decoder = NULL;
2534
2535     if (related_stream >= 0 && wanted_stream_nb < 0) {
2536         AVProgram *p = find_program_from_stream(ic, related_stream);
2537         if (p) {
2538             program = p->stream_index;
2539             nb_streams = p->nb_stream_indexes;
2540         }
2541     }
2542     for (i = 0; i < nb_streams; i++) {
2543         int real_stream_index = program ? program[i] : i;
2544         AVStream *st = ic->streams[real_stream_index];
2545         AVCodecContext *avctx = st->codec;
2546         if (avctx->codec_type != type)
2547             continue;
2548         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2549             continue;
2550         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2551             continue;
2552         if (decoder_ret) {
2553             decoder = avcodec_find_decoder(st->codec->codec_id);
2554             if (!decoder) {
2555                 if (ret < 0)
2556                     ret = AVERROR_DECODER_NOT_FOUND;
2557                 continue;
2558             }
2559         }
2560         if (best_count >= st->codec_info_nb_frames)
2561             continue;
2562         best_count = st->codec_info_nb_frames;
2563         ret = real_stream_index;
2564         best_decoder = decoder;
2565         if (program && i == nb_streams - 1 && ret < 0) {
2566             program = NULL;
2567             nb_streams = ic->nb_streams;
2568             i = 0; /* no related stream found, try again with everything */
2569         }
2570     }
2571     if (decoder_ret)
2572         *decoder_ret = best_decoder;
2573     return ret;
2574 }
2575
2576 /*******************************************************/
2577
2578 int av_read_play(AVFormatContext *s)
2579 {
2580     if (s->iformat->read_play)
2581         return s->iformat->read_play(s);
2582     if (s->pb)
2583         return avio_pause(s->pb, 0);
2584     return AVERROR(ENOSYS);
2585 }
2586
2587 int av_read_pause(AVFormatContext *s)
2588 {
2589     if (s->iformat->read_pause)
2590         return s->iformat->read_pause(s);
2591     if (s->pb)
2592         return avio_pause(s->pb, 1);
2593     return AVERROR(ENOSYS);
2594 }
2595
2596 void avformat_free_context(AVFormatContext *s)
2597 {
2598     int i;
2599     AVStream *st;
2600
2601     av_opt_free(s);
2602     if (s->iformat && s->iformat->priv_class && s->priv_data)
2603         av_opt_free(s->priv_data);
2604
2605     for(i=0;i<s->nb_streams;i++) {
2606         /* free all data in a stream component */
2607         st = s->streams[i];
2608         if (st->parser) {
2609             av_parser_close(st->parser);
2610         }
2611         if (st->attached_pic.data)
2612             av_free_packet(&st->attached_pic);
2613         av_dict_free(&st->metadata);
2614         av_free(st->index_entries);
2615         av_free(st->codec->extradata);
2616         av_free(st->codec->subtitle_header);
2617         av_free(st->codec);
2618         av_free(st->priv_data);
2619         av_free(st->info);
2620         av_free(st);
2621     }
2622     for(i=s->nb_programs-1; i>=0; i--) {
2623         av_dict_free(&s->programs[i]->metadata);
2624         av_freep(&s->programs[i]->stream_index);
2625         av_freep(&s->programs[i]);
2626     }
2627     av_freep(&s->programs);
2628     av_freep(&s->priv_data);
2629     while(s->nb_chapters--) {
2630         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2631         av_free(s->chapters[s->nb_chapters]);
2632     }
2633     av_freep(&s->chapters);
2634     av_dict_free(&s->metadata);
2635     av_freep(&s->streams);
2636     av_free(s);
2637 }
2638
2639 #if FF_API_CLOSE_INPUT_FILE
2640 void av_close_input_file(AVFormatContext *s)
2641 {
2642     avformat_close_input(&s);
2643 }
2644 #endif
2645
2646 void avformat_close_input(AVFormatContext **ps)
2647 {
2648     AVFormatContext *s = *ps;
2649     AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2650                        NULL : s->pb;
2651     flush_packet_queue(s);
2652     if (s->iformat->read_close)
2653         s->iformat->read_close(s);
2654     avformat_free_context(s);
2655     *ps = NULL;
2656     if (pb)
2657         avio_close(pb);
2658 }
2659
2660 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2661 {
2662     AVStream *st;
2663     int i;
2664     AVStream **streams;
2665
2666     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2667         return NULL;
2668     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2669     if (!streams)
2670         return NULL;
2671     s->streams = streams;
2672
2673     st = av_mallocz(sizeof(AVStream));
2674     if (!st)
2675         return NULL;
2676     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2677         av_free(st);
2678         return NULL;
2679     }
2680
2681     st->codec = avcodec_alloc_context3(c);
2682     if (s->iformat) {
2683         /* no default bitrate if decoding */
2684         st->codec->bit_rate = 0;
2685     }
2686     st->index = s->nb_streams;
2687     st->start_time = AV_NOPTS_VALUE;
2688     st->duration = AV_NOPTS_VALUE;
2689         /* we set the current DTS to 0 so that formats without any timestamps
2690            but durations get some timestamps, formats with some unknown
2691            timestamps have their first few packets buffered and the
2692            timestamps corrected before they are returned to the user */
2693     st->cur_dts = 0;
2694     st->first_dts = AV_NOPTS_VALUE;
2695     st->probe_packets = MAX_PROBE_PACKETS;
2696
2697     /* default pts setting is MPEG-like */
2698     avpriv_set_pts_info(st, 33, 1, 90000);
2699     st->last_IP_pts = AV_NOPTS_VALUE;
2700     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2701         st->pts_buffer[i]= AV_NOPTS_VALUE;
2702     st->reference_dts = AV_NOPTS_VALUE;
2703
2704     st->sample_aspect_ratio = (AVRational){0,1};
2705
2706     s->streams[s->nb_streams++] = st;
2707     return st;
2708 }
2709
2710 AVProgram *av_new_program(AVFormatContext *ac, int id)
2711 {
2712     AVProgram *program=NULL;
2713     int i;
2714
2715     av_dlog(ac, "new_program: id=0x%04x\n", id);
2716
2717     for(i=0; i<ac->nb_programs; i++)
2718         if(ac->programs[i]->id == id)
2719             program = ac->programs[i];
2720
2721     if(!program){
2722         program = av_mallocz(sizeof(AVProgram));
2723         if (!program)
2724             return NULL;
2725         dynarray_add(&ac->programs, &ac->nb_programs, program);
2726         program->discard = AVDISCARD_NONE;
2727     }
2728     program->id = id;
2729
2730     return program;
2731 }
2732
2733 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2734 {
2735     AVChapter *chapter = NULL;
2736     int i;
2737
2738     for(i=0; i<s->nb_chapters; i++)
2739         if(s->chapters[i]->id == id)
2740             chapter = s->chapters[i];
2741
2742     if(!chapter){
2743         chapter= av_mallocz(sizeof(AVChapter));
2744         if(!chapter)
2745             return NULL;
2746         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2747     }
2748     av_dict_set(&chapter->metadata, "title", title, 0);
2749     chapter->id    = id;
2750     chapter->time_base= time_base;
2751     chapter->start = start;
2752     chapter->end   = end;
2753
2754     return chapter;
2755 }
2756
2757 /************************************************************/
2758 /* output media file */
2759
2760 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2761 {
2762     const AVCodecTag *avctag;
2763     int n;
2764     enum CodecID id = CODEC_ID_NONE;
2765     unsigned int tag = 0;
2766
2767     /**
2768      * Check that tag + id is in the table
2769      * If neither is in the table -> OK
2770      * If tag is in the table with another id -> FAIL
2771      * If id is in the table with another tag -> FAIL unless strict < normal
2772      */
2773     for (n = 0; s->oformat->codec_tag[n]; n++) {
2774         avctag = s->oformat->codec_tag[n];
2775         while (avctag->id != CODEC_ID_NONE) {
2776             if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
2777                 id = avctag->id;
2778                 if (id == st->codec->codec_id)
2779                     return 1;
2780             }
2781             if (avctag->id == st->codec->codec_id)
2782                 tag = avctag->tag;
2783             avctag++;
2784         }
2785     }
2786     if (id != CODEC_ID_NONE)
2787         return 0;
2788     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2789         return 0;
2790     return 1;
2791 }
2792
2793 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2794 {
2795     int ret = 0, i;
2796     AVStream *st;
2797     AVDictionary *tmp = NULL;
2798
2799     if (options)
2800         av_dict_copy(&tmp, *options, 0);
2801     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2802         goto fail;
2803
2804     // some sanity checks
2805     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2806         av_log(s, AV_LOG_ERROR, "no streams\n");
2807         ret = AVERROR(EINVAL);
2808         goto fail;
2809     }
2810
2811     for(i=0;i<s->nb_streams;i++) {
2812         st = s->streams[i];
2813
2814         switch (st->codec->codec_type) {
2815         case AVMEDIA_TYPE_AUDIO:
2816             if(st->codec->sample_rate<=0){
2817                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2818                 ret = AVERROR(EINVAL);
2819                 goto fail;
2820             }
2821             if(!st->codec->block_align)
2822                 st->codec->block_align = st->codec->channels *
2823                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2824             break;
2825         case AVMEDIA_TYPE_VIDEO:
2826             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2827                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2828                 ret = AVERROR(EINVAL);
2829                 goto fail;
2830             }
2831             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2832                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2833                 ret = AVERROR(EINVAL);
2834                 goto fail;
2835             }
2836             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2837                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
2838                        "(%d/%d) and encoder layer (%d/%d)\n",
2839                        st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2840                        st->codec->sample_aspect_ratio.num,
2841                        st->codec->sample_aspect_ratio.den);
2842                 ret = AVERROR(EINVAL);
2843                 goto fail;
2844             }
2845             break;
2846         }
2847
2848         if(s->oformat->codec_tag){
2849             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)){
2850                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2851                 st->codec->codec_tag= 0;
2852             }
2853             if(st->codec->codec_tag){
2854                 if (!validate_codec_tag(s, st)) {
2855                     char tagbuf[32];
2856                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2857                     av_log(s, AV_LOG_ERROR,
2858                            "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2859                            tagbuf, st->codec->codec_tag, st->codec->codec_id);
2860                     ret = AVERROR_INVALIDDATA;
2861                     goto fail;
2862                 }
2863             }else
2864                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2865         }
2866
2867         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2868             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2869           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2870     }
2871
2872     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2873         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2874         if (!s->priv_data) {
2875             ret = AVERROR(ENOMEM);
2876             goto fail;
2877         }
2878         if (s->oformat->priv_class) {
2879             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2880             av_opt_set_defaults(s->priv_data);
2881             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2882                 goto fail;
2883         }
2884     }
2885
2886     /* set muxer identification string */
2887     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2888         av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2889     }
2890
2891     if(s->oformat->write_header){
2892         ret = s->oformat->write_header(s);
2893         if (ret < 0)
2894             goto fail;
2895     }
2896
2897     /* init PTS generation */
2898     for(i=0;i<s->nb_streams;i++) {
2899         int64_t den = AV_NOPTS_VALUE;
2900         st = s->streams[i];
2901
2902         switch (st->codec->codec_type) {
2903         case AVMEDIA_TYPE_AUDIO:
2904             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2905             break;
2906         case AVMEDIA_TYPE_VIDEO:
2907             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2908             break;
2909         default:
2910             break;
2911         }
2912         if (den != AV_NOPTS_VALUE) {
2913             if (den <= 0) {
2914                 ret = AVERROR_INVALIDDATA;
2915                 goto fail;
2916             }
2917             frac_init(&st->pts, 0, 0, den);
2918         }
2919     }
2920
2921     if (options) {
2922         av_dict_free(options);
2923         *options = tmp;
2924     }
2925     return 0;
2926 fail:
2927     av_dict_free(&tmp);
2928     return ret;
2929 }
2930
2931 //FIXME merge with compute_pkt_fields
2932 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2933     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2934     int num, den, frame_size, i;
2935
2936     av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2937             pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2938
2939 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2940         return AVERROR(EINVAL);*/
2941
2942     /* duration field */
2943     if (pkt->duration == 0) {
2944         compute_frame_duration(&num, &den, st, NULL, pkt);
2945         if (den && num) {
2946             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2947         }
2948     }
2949
2950     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2951         pkt->pts= pkt->dts;
2952
2953     //XXX/FIXME this is a temporary hack until all encoders output pts
2954     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2955         pkt->dts=
2956 //        pkt->pts= st->cur_dts;
2957         pkt->pts= st->pts.val;
2958     }
2959
2960     //calculate dts from pts
2961     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2962         st->pts_buffer[0]= pkt->pts;
2963         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2964             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2965         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2966             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2967
2968         pkt->dts= st->pts_buffer[0];
2969     }
2970
2971     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2972         av_log(s, AV_LOG_ERROR,
2973                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2974                st->index, st->cur_dts, pkt->dts);
2975         return AVERROR(EINVAL);
2976     }
2977     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2978         av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2979         return AVERROR(EINVAL);
2980     }
2981
2982 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2983     st->cur_dts= pkt->dts;
2984     st->pts.val= pkt->dts;
2985
2986     /* update pts */
2987     switch (st->codec->codec_type) {
2988     case AVMEDIA_TYPE_AUDIO:
2989         frame_size = get_audio_frame_size(st->codec, pkt->size, 1);
2990
2991         /* HACK/FIXME, we skip the initial 0 size packets as they are most
2992            likely equal to the encoder delay, but it would be better if we
2993            had the real timestamps from the encoder */
2994         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2995             frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2996         }
2997         break;
2998     case AVMEDIA_TYPE_VIDEO:
2999         frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3000         break;
3001     default:
3002         break;
3003     }
3004     return 0;
3005 }
3006
3007 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3008 {
3009     int ret;
3010
3011     if (!pkt) {
3012         if (s->oformat->flags & AVFMT_ALLOW_FLUSH)
3013             return s->oformat->write_packet(s, pkt);
3014         return 1;
3015     }
3016
3017     ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3018
3019     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3020         return ret;
3021
3022     ret= s->oformat->write_packet(s, pkt);
3023
3024     if (ret >= 0)
3025         s->streams[pkt->stream_index]->nb_frames++;
3026     return ret;
3027 }
3028
3029 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3030                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3031 {
3032     AVPacketList **next_point, *this_pktl;
3033
3034     this_pktl = av_mallocz(sizeof(AVPacketList));
3035     this_pktl->pkt= *pkt;
3036     pkt->destruct= NULL;             // do not free original but only the copy
3037     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3038
3039     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3040         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3041     }else
3042         next_point = &s->packet_buffer;
3043
3044     if(*next_point){
3045         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3046             while(!compare(s, &(*next_point)->pkt, pkt)){
3047                 next_point= &(*next_point)->next;
3048             }
3049             goto next_non_null;
3050         }else{
3051             next_point = &(s->packet_buffer_end->next);
3052         }
3053     }
3054     assert(!*next_point);
3055
3056     s->packet_buffer_end= this_pktl;
3057 next_non_null:
3058
3059     this_pktl->next= *next_point;
3060
3061     s->streams[pkt->stream_index]->last_in_packet_buffer=
3062     *next_point= this_pktl;
3063 }
3064
3065 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3066 {
3067     AVStream *st = s->streams[ pkt ->stream_index];
3068     AVStream *st2= s->streams[ next->stream_index];
3069     int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3070                              st->time_base);
3071
3072     if (comp == 0)
3073         return pkt->stream_index < next->stream_index;
3074     return comp > 0;
3075 }
3076
3077 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3078     AVPacketList *pktl;
3079     int stream_count=0;
3080     int i;
3081
3082     if(pkt){
3083         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3084     }
3085
3086     for(i=0; i < s->nb_streams; i++)
3087         stream_count+= !!s->streams[i]->last_in_packet_buffer;
3088
3089     if(stream_count && (s->nb_streams == stream_count || flush)){
3090         pktl= s->packet_buffer;
3091         *out= pktl->pkt;
3092
3093         s->packet_buffer= pktl->next;
3094         if(!s->packet_buffer)
3095             s->packet_buffer_end= NULL;
3096
3097         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3098             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3099         av_freep(&pktl);
3100         return 1;
3101     }else{
3102         av_init_packet(out);
3103         return 0;
3104     }
3105 }
3106
3107 /**
3108  * Interleave an AVPacket correctly so it can be muxed.
3109  * @param out the interleaved packet will be output here
3110  * @param in the input packet
3111  * @param flush 1 if no further packets are available as input and all
3112  *              remaining packets should be output
3113  * @return 1 if a packet was output, 0 if no packet could be output,
3114  *         < 0 if an error occurred
3115  */
3116 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3117     if (s->oformat->interleave_packet) {
3118         int ret = s->oformat->interleave_packet(s, out, in, flush);
3119         if (in)
3120             av_free_packet(in);
3121         return ret;
3122     } else
3123         return av_interleave_packet_per_dts(s, out, in, flush);
3124 }
3125
3126 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3127     AVStream *st= s->streams[ pkt->stream_index];
3128     int ret;
3129
3130     //FIXME/XXX/HACK drop zero sized packets
3131     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3132         return 0;
3133
3134     av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3135             pkt->size, pkt->dts, pkt->pts);
3136     if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3137         return ret;
3138
3139     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3140         return AVERROR(EINVAL);
3141
3142     for(;;){
3143         AVPacket opkt;
3144         int ret= interleave_packet(s, &opkt, pkt, 0);
3145         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3146             return ret;
3147
3148         ret= s->oformat->write_packet(s, &opkt);
3149         if (ret >= 0)
3150             s->streams[opkt.stream_index]->nb_frames++;
3151
3152         av_free_packet(&opkt);
3153         pkt= NULL;
3154
3155         if(ret<0)
3156             return ret;
3157     }
3158 }
3159
3160 int av_write_trailer(AVFormatContext *s)
3161 {
3162     int ret, i;
3163
3164     for(;;){
3165         AVPacket pkt;
3166         ret= interleave_packet(s, &pkt, NULL, 1);
3167         if(ret<0) //FIXME cleanup needed for ret<0 ?
3168             goto fail;
3169         if(!ret)
3170             break;
3171
3172         ret= s->oformat->write_packet(s, &pkt);
3173         if (ret >= 0)
3174             s->streams[pkt.stream_index]->nb_frames++;
3175
3176         av_free_packet(&pkt);
3177
3178         if(ret<0)
3179             goto fail;
3180     }
3181
3182     if(s->oformat->write_trailer)
3183         ret = s->oformat->write_trailer(s);
3184 fail:
3185     for(i=0;i<s->nb_streams;i++) {
3186         av_freep(&s->streams[i]->priv_data);
3187         av_freep(&s->streams[i]->index_entries);
3188     }
3189     if (s->oformat->priv_class)
3190         av_opt_free(s->priv_data);
3191     av_freep(&s->priv_data);
3192     return ret;
3193 }
3194
3195 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3196 {
3197     int i, j;
3198     AVProgram *program=NULL;
3199     void *tmp;
3200
3201     if (idx >= ac->nb_streams) {
3202         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3203         return;
3204     }
3205
3206     for(i=0; i<ac->nb_programs; i++){
3207         if(ac->programs[i]->id != progid)
3208             continue;
3209         program = ac->programs[i];
3210         for(j=0; j<program->nb_stream_indexes; j++)
3211             if(program->stream_index[j] == idx)
3212                 return;
3213
3214         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3215         if(!tmp)
3216             return;
3217         program->stream_index = tmp;
3218         program->stream_index[program->nb_stream_indexes++] = idx;
3219         return;
3220     }
3221 }
3222
3223 static void print_fps(double d, const char *postfix){
3224     uint64_t v= lrintf(d*100);
3225     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3226     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3227     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3228 }
3229
3230 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3231 {
3232     if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3233         AVDictionaryEntry *tag=NULL;
3234
3235         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3236         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3237             if(strcmp("language", tag->key))
3238                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3239         }
3240     }
3241 }
3242
3243 /* "user interface" functions */
3244 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3245 {
3246     char buf[256];
3247     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3248     AVStream *st = ic->streams[i];
3249     int g = av_gcd(st->time_base.num, st->time_base.den);
3250     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3251     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3252     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3253     /* the pid is an important information, so we display it */
3254     /* XXX: add a generic system */
3255     if (flags & AVFMT_SHOW_IDS)
3256         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3257     if (lang)
3258         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3259     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3260     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3261     if (st->sample_aspect_ratio.num && // default
3262         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3263         AVRational display_aspect_ratio;
3264         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3265                   st->codec->width*st->sample_aspect_ratio.num,
3266                   st->codec->height*st->sample_aspect_ratio.den,
3267                   1024*1024);
3268         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3269                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3270                  display_aspect_ratio.num, display_aspect_ratio.den);
3271     }
3272     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3273         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3274             print_fps(av_q2d(st->avg_frame_rate), "fps");
3275         if(st->r_frame_rate.den && st->r_frame_rate.num)
3276             print_fps(av_q2d(st->r_frame_rate), "tbr");
3277         if(st->time_base.den && st->time_base.num)
3278             print_fps(1/av_q2d(st->time_base), "tbn");
3279         if(st->codec->time_base.den && st->codec->time_base.num)
3280             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3281     }
3282     if (st->disposition & AV_DISPOSITION_DEFAULT)
3283         av_log(NULL, AV_LOG_INFO, " (default)");
3284     if (st->disposition & AV_DISPOSITION_DUB)
3285         av_log(NULL, AV_LOG_INFO, " (dub)");
3286     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3287         av_log(NULL, AV_LOG_INFO, " (original)");
3288     if (st->disposition & AV_DISPOSITION_COMMENT)
3289         av_log(NULL, AV_LOG_INFO, " (comment)");
3290     if (st->disposition & AV_DISPOSITION_LYRICS)
3291         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3292     if (st->disposition & AV_DISPOSITION_KARAOKE)
3293         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3294     if (st->disposition & AV_DISPOSITION_FORCED)
3295         av_log(NULL, AV_LOG_INFO, " (forced)");
3296     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3297         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3298     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3299         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3300     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3301         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3302     av_log(NULL, AV_LOG_INFO, "\n");
3303     dump_metadata(NULL, st->metadata, "    ");
3304 }
3305
3306 void av_dump_format(AVFormatContext *ic,
3307                     int index,
3308                     const char *url,
3309                     int is_output)
3310 {
3311     int i;
3312     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3313     if (ic->nb_streams && !printed)
3314         return;
3315
3316     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3317             is_output ? "Output" : "Input",
3318             index,
3319             is_output ? ic->oformat->name : ic->iformat->name,
3320             is_output ? "to" : "from", url);
3321     dump_metadata(NULL, ic->metadata, "  ");
3322     if (!is_output) {
3323         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3324         if (ic->duration != AV_NOPTS_VALUE) {
3325             int hours, mins, secs, us;
3326             secs = ic->duration / AV_TIME_BASE;
3327             us = ic->duration % AV_TIME_BASE;
3328             mins = secs / 60;
3329             secs %= 60;
3330             hours = mins / 60;
3331             mins %= 60;
3332             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3333                    (100 * us) / AV_TIME_BASE);
3334         } else {
3335             av_log(NULL, AV_LOG_INFO, "N/A");
3336         }
3337         if (ic->start_time != AV_NOPTS_VALUE) {
3338             int secs, us;
3339             av_log(NULL, AV_LOG_INFO, ", start: ");
3340             secs = ic->start_time / AV_TIME_BASE;
3341             us = abs(ic->start_time % AV_TIME_BASE);
3342             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3343                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3344         }
3345         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3346         if (ic->bit_rate) {
3347             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3348         } else {
3349             av_log(NULL, AV_LOG_INFO, "N/A");
3350         }
3351         av_log(NULL, AV_LOG_INFO, "\n");
3352     }
3353     for (i = 0; i < ic->nb_chapters; i++) {
3354         AVChapter *ch = ic->chapters[i];
3355         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3356         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3357         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3358
3359         dump_metadata(NULL, ch->metadata, "    ");
3360     }
3361     if(ic->nb_programs) {
3362         int j, k, total = 0;
3363         for(j=0; j<ic->nb_programs; j++) {
3364             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3365                                                   "name", NULL, 0);
3366             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3367                    name ? name->value : "");
3368             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3369             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3370                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3371                 printed[ic->programs[j]->stream_index[k]] = 1;
3372             }
3373             total += ic->programs[j]->nb_stream_indexes;
3374         }
3375         if (total < ic->nb_streams)
3376             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3377     }
3378     for(i=0;i<ic->nb_streams;i++)
3379         if (!printed[i])
3380             dump_stream_format(ic, i, index, is_output);
3381
3382     av_free(printed);
3383 }
3384
3385 int64_t av_gettime(void)
3386 {
3387     struct timeval tv;
3388     gettimeofday(&tv,NULL);
3389     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3390 }
3391
3392 uint64_t ff_ntp_time(void)
3393 {
3394   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3395 }
3396
3397 int av_get_frame_filename(char *buf, int buf_size,
3398                           const char *path, int number)
3399 {
3400     const char *p;
3401     char *q, buf1[20], c;
3402     int nd, len, percentd_found;
3403
3404     q = buf;
3405     p = path;
3406     percentd_found = 0;
3407     for(;;) {
3408         c = *p++;
3409         if (c == '\0')
3410             break;
3411         if (c == '%') {
3412             do {
3413                 nd = 0;
3414                 while (isdigit(*p)) {
3415                     nd = nd * 10 + *p++ - '0';
3416                 }
3417                 c = *p++;
3418             } while (isdigit(c));
3419
3420             switch(c) {
3421             case '%':
3422                 goto addchar;
3423             case 'd':
3424                 if (percentd_found)
3425                     goto fail;
3426                 percentd_found = 1;
3427                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3428                 len = strlen(buf1);
3429                 if ((q - buf + len) > buf_size - 1)
3430                     goto fail;
3431                 memcpy(q, buf1, len);
3432                 q += len;
3433                 break;
3434             default:
3435                 goto fail;
3436             }
3437         } else {
3438         addchar:
3439             if ((q - buf) < buf_size - 1)
3440                 *q++ = c;
3441         }
3442     }
3443     if (!percentd_found)
3444         goto fail;
3445     *q = '\0';
3446     return 0;
3447  fail:
3448     *q = '\0';
3449     return -1;
3450 }
3451
3452 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3453 {
3454     int len, i, j, c;
3455 #undef fprintf
3456 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3457
3458     for(i=0;i<size;i+=16) {
3459         len = size - i;
3460         if (len > 16)
3461             len = 16;
3462         PRINT("%08x ", i);
3463         for(j=0;j<16;j++) {
3464             if (j < len)
3465                 PRINT(" %02x", buf[i+j]);
3466             else
3467                 PRINT("   ");
3468         }
3469         PRINT(" ");
3470         for(j=0;j<len;j++) {
3471             c = buf[i+j];
3472             if (c < ' ' || c > '~')
3473                 c = '.';
3474             PRINT("%c", c);
3475         }
3476         PRINT("\n");
3477     }
3478 #undef PRINT
3479 }
3480
3481 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3482 {
3483     hex_dump_internal(NULL, f, 0, buf, size);
3484 }
3485
3486 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3487 {
3488     hex_dump_internal(avcl, NULL, level, buf, size);
3489 }
3490
3491 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3492 {
3493 #undef fprintf
3494 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3495     PRINT("stream #%d:\n", pkt->stream_index);
3496     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3497     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3498     /* DTS is _always_ valid after av_read_frame() */
3499     PRINT("  dts=");
3500     if (pkt->dts == AV_NOPTS_VALUE)
3501         PRINT("N/A");
3502     else
3503         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3504     /* PTS may not be known if B-frames are present. */
3505     PRINT("  pts=");
3506     if (pkt->pts == AV_NOPTS_VALUE)
3507         PRINT("N/A");
3508     else
3509         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3510     PRINT("\n");
3511     PRINT("  size=%d\n", pkt->size);
3512 #undef PRINT
3513     if (dump_payload)
3514         av_hex_dump(f, pkt->data, pkt->size);
3515 }
3516
3517 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3518 {
3519     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3520 }
3521
3522 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3523                       AVStream *st)
3524 {
3525     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3526 }
3527
3528 void av_url_split(char *proto, int proto_size,
3529                   char *authorization, int authorization_size,
3530                   char *hostname, int hostname_size,
3531                   int *port_ptr,
3532                   char *path, int path_size,
3533                   const char *url)
3534 {
3535     const char *p, *ls, *at, *col, *brk;
3536
3537     if (port_ptr)               *port_ptr = -1;
3538     if (proto_size > 0)         proto[0] = 0;
3539     if (authorization_size > 0) authorization[0] = 0;
3540     if (hostname_size > 0)      hostname[0] = 0;
3541     if (path_size > 0)          path[0] = 0;
3542
3543     /* parse protocol */
3544     if ((p = strchr(url, ':'))) {
3545         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3546         p++; /* skip ':' */
3547         if (*p == '/') p++;
3548         if (*p == '/') p++;
3549     } else {
3550         /* no protocol means plain filename */
3551         av_strlcpy(path, url, path_size);
3552         return;
3553     }
3554
3555     /* separate path from hostname */
3556     ls = strchr(p, '/');
3557     if(!ls)
3558         ls = strchr(p, '?');
3559     if(ls)
3560         av_strlcpy(path, ls, path_size);
3561     else
3562         ls = &p[strlen(p)]; // XXX
3563
3564     /* the rest is hostname, use that to parse auth/port */
3565     if (ls != p) {
3566         /* authorization (user[:pass]@hostname) */
3567         if ((at = strchr(p, '@')) && at < ls) {
3568             av_strlcpy(authorization, p,
3569                        FFMIN(authorization_size, at + 1 - p));
3570             p = at + 1; /* skip '@' */
3571         }
3572
3573         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3574             /* [host]:port */
3575             av_strlcpy(hostname, p + 1,
3576                        FFMIN(hostname_size, brk - p));
3577             if (brk[1] == ':' && port_ptr)
3578                 *port_ptr = atoi(brk + 2);
3579         } else if ((col = strchr(p, ':')) && col < ls) {
3580             av_strlcpy(hostname, p,
3581                        FFMIN(col + 1 - p, hostname_size));
3582             if (port_ptr) *port_ptr = atoi(col + 1);
3583         } else
3584             av_strlcpy(hostname, p,
3585                        FFMIN(ls + 1 - p, hostname_size));
3586     }
3587 }
3588
3589 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3590 {
3591     int i;
3592     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3593                                            '4', '5', '6', '7',
3594                                            '8', '9', 'A', 'B',
3595                                            'C', 'D', 'E', 'F' };
3596     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3597                                            '4', '5', '6', '7',
3598                                            '8', '9', 'a', 'b',
3599                                            'c', 'd', 'e', 'f' };
3600     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3601
3602     for(i = 0; i < s; i++) {
3603         buff[i * 2]     = hex_table[src[i] >> 4];
3604         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3605     }
3606
3607     return buff;
3608 }
3609
3610 int ff_hex_to_data(uint8_t *data, const char *p)
3611 {
3612     int c, len, v;
3613
3614     len = 0;
3615     v = 1;
3616     for (;;) {
3617         p += strspn(p, SPACE_CHARS);
3618         if (*p == '\0')
3619             break;
3620         c = toupper((unsigned char) *p++);
3621         if (c >= '0' && c <= '9')
3622             c = c - '0';
3623         else if (c >= 'A' && c <= 'F')
3624             c = c - 'A' + 10;
3625         else
3626             break;
3627         v = (v << 4) | c;
3628         if (v & 0x100) {
3629             if (data)
3630                 data[len] = v;
3631             len++;
3632             v = 1;
3633         }
3634     }
3635     return len;
3636 }
3637
3638 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3639                          unsigned int pts_num, unsigned int pts_den)
3640 {
3641     AVRational new_tb;
3642     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3643         if(new_tb.num != pts_num)
3644             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3645     }else
3646         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3647
3648     if(new_tb.num <= 0 || new_tb.den <= 0) {
3649         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3650         return;
3651     }
3652     s->time_base = new_tb;
3653     s->pts_wrap_bits = pts_wrap_bits;
3654 }
3655
3656 int ff_url_join(char *str, int size, const char *proto,
3657                 const char *authorization, const char *hostname,
3658                 int port, const char *fmt, ...)
3659 {
3660 #if CONFIG_NETWORK
3661     struct addrinfo hints, *ai;
3662 #endif
3663
3664     str[0] = '\0';
3665     if (proto)
3666         av_strlcatf(str, size, "%s://", proto);
3667     if (authorization && authorization[0])
3668         av_strlcatf(str, size, "%s@", authorization);
3669 #if CONFIG_NETWORK && defined(AF_INET6)
3670     /* Determine if hostname is a numerical IPv6 address,
3671      * properly escape it within [] in that case. */
3672     memset(&hints, 0, sizeof(hints));
3673     hints.ai_flags = AI_NUMERICHOST;
3674     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3675         if (ai->ai_family == AF_INET6) {
3676             av_strlcat(str, "[", size);
3677             av_strlcat(str, hostname, size);
3678             av_strlcat(str, "]", size);
3679         } else {
3680             av_strlcat(str, hostname, size);
3681         }
3682         freeaddrinfo(ai);
3683     } else
3684 #endif
3685         /* Not an IPv6 address, just output the plain string. */
3686         av_strlcat(str, hostname, size);
3687
3688     if (port >= 0)
3689         av_strlcatf(str, size, ":%d", port);
3690     if (fmt) {
3691         va_list vl;
3692         int len = strlen(str);
3693
3694         va_start(vl, fmt);
3695         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3696         va_end(vl);
3697     }
3698     return strlen(str);
3699 }
3700
3701 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3702                      AVFormatContext *src)
3703 {
3704     AVPacket local_pkt;
3705
3706     local_pkt = *pkt;
3707     local_pkt.stream_index = dst_stream;
3708     if (pkt->pts != AV_NOPTS_VALUE)
3709         local_pkt.pts = av_rescale_q(pkt->pts,
3710                                      src->streams[pkt->stream_index]->time_base,
3711                                      dst->streams[dst_stream]->time_base);
3712     if (pkt->dts != AV_NOPTS_VALUE)
3713         local_pkt.dts = av_rescale_q(pkt->dts,
3714                                      src->streams[pkt->stream_index]->time_base,
3715                                      dst->streams[dst_stream]->time_base);
3716     return av_write_frame(dst, &local_pkt);
3717 }
3718
3719 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3720                         void *context)
3721 {
3722     const char *ptr = str;
3723
3724     /* Parse key=value pairs. */
3725     for (;;) {
3726         const char *key;
3727         char *dest = NULL, *dest_end;
3728         int key_len, dest_len = 0;
3729
3730         /* Skip whitespace and potential commas. */
3731         while (*ptr && (isspace(*ptr) || *ptr == ','))
3732             ptr++;
3733         if (!*ptr)
3734             break;
3735
3736         key = ptr;
3737
3738         if (!(ptr = strchr(key, '=')))
3739             break;
3740         ptr++;
3741         key_len = ptr - key;
3742
3743         callback_get_buf(context, key, key_len, &dest, &dest_len);
3744         dest_end = dest + dest_len - 1;
3745
3746         if (*ptr == '\"') {
3747             ptr++;
3748             while (*ptr && *ptr != '\"') {
3749                 if (*ptr == '\\') {
3750                     if (!ptr[1])
3751                         break;
3752                     if (dest && dest < dest_end)
3753                         *dest++ = ptr[1];
3754                     ptr += 2;
3755                 } else {
3756                     if (dest && dest < dest_end)
3757                         *dest++ = *ptr;
3758                     ptr++;
3759                 }
3760             }
3761             if (*ptr == '\"')
3762                 ptr++;
3763         } else {
3764             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3765                 if (dest && dest < dest_end)
3766                     *dest++ = *ptr;
3767         }
3768         if (dest)
3769             *dest = 0;
3770     }
3771 }
3772
3773 int ff_find_stream_index(AVFormatContext *s, int id)
3774 {
3775     int i;
3776     for (i = 0; i < s->nb_streams; i++) {
3777         if (s->streams[i]->id == id)
3778             return i;
3779     }
3780     return -1;
3781 }
3782
3783 void ff_make_absolute_url(char *buf, int size, const char *base,
3784                           const char *rel)
3785 {
3786     char *sep;
3787     /* Absolute path, relative to the current server */
3788     if (base && strstr(base, "://") && rel[0] == '/') {
3789         if (base != buf)
3790             av_strlcpy(buf, base, size);
3791         sep = strstr(buf, "://");
3792         if (sep) {
3793             sep += 3;
3794             sep = strchr(sep, '/');
3795             if (sep)
3796                 *sep = '\0';
3797         }
3798         av_strlcat(buf, rel, size);
3799         return;
3800     }
3801     /* If rel actually is an absolute url, just copy it */
3802     if (!base || strstr(rel, "://") || rel[0] == '/') {
3803         av_strlcpy(buf, rel, size);
3804         return;
3805     }
3806     if (base != buf)
3807         av_strlcpy(buf, base, size);
3808     /* Remove the file name from the base url */
3809     sep = strrchr(buf, '/');
3810     if (sep)
3811         sep[1] = '\0';
3812     else
3813         buf[0] = '\0';
3814     while (av_strstart(rel, "../", NULL) && sep) {
3815         /* Remove the path delimiter at the end */
3816         sep[0] = '\0';
3817         sep = strrchr(buf, '/');
3818         /* If the next directory name to pop off is "..", break here */
3819         if (!strcmp(sep ? &sep[1] : buf, "..")) {
3820             /* Readd the slash we just removed */
3821             av_strlcat(buf, "/", size);
3822             break;
3823         }
3824         /* Cut off the directory name */
3825         if (sep)
3826             sep[1] = '\0';
3827         else
3828             buf[0] = '\0';
3829         rel += 3;
3830     }
3831     av_strlcat(buf, rel, size);
3832 }
3833
3834 int64_t ff_iso8601_to_unix_time(const char *datestr)
3835 {
3836 #if HAVE_STRPTIME
3837     struct tm time1 = {0}, time2 = {0};
3838     char *ret1, *ret2;
3839     ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
3840     ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
3841     if (ret2 && !ret1)
3842         return av_timegm(&time2);
3843     else
3844         return av_timegm(&time1);
3845 #else
3846     av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
3847                                  "the date string.\n");
3848     return 0;
3849 #endif
3850 }
3851
3852 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
3853 {
3854     if (ofmt) {
3855         if (ofmt->query_codec)
3856             return ofmt->query_codec(codec_id, std_compliance);
3857         else if (ofmt->codec_tag)
3858             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
3859         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
3860                  codec_id == ofmt->subtitle_codec)
3861             return 1;
3862     }
3863     return AVERROR_PATCHWELCOME;
3864 }
3865
3866 int avformat_network_init(void)
3867 {
3868 #if CONFIG_NETWORK
3869     int ret;
3870     ff_network_inited_globally = 1;
3871     if ((ret = ff_network_init()) < 0)
3872         return ret;
3873     ff_tls_init();
3874 #endif
3875     return 0;
3876 }
3877
3878 int avformat_network_deinit(void)
3879 {
3880 #if CONFIG_NETWORK
3881     ff_network_close();
3882     ff_tls_deinit();
3883 #endif
3884     return 0;
3885 }
3886
3887 int ff_add_param_change(AVPacket *pkt, int32_t channels,
3888                         uint64_t channel_layout, int32_t sample_rate,
3889                         int32_t width, int32_t height)
3890 {
3891     uint32_t flags = 0;
3892     int size = 4;
3893     uint8_t *data;
3894     if (!pkt)
3895         return AVERROR(EINVAL);
3896     if (channels) {
3897         size += 4;
3898         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
3899     }
3900     if (channel_layout) {
3901         size += 8;
3902         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
3903     }
3904     if (sample_rate) {
3905         size += 4;
3906         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
3907     }
3908     if (width || height) {
3909         size += 8;
3910         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
3911     }
3912     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
3913     if (!data)
3914         return AVERROR(ENOMEM);
3915     bytestream_put_le32(&data, flags);
3916     if (channels)
3917         bytestream_put_le32(&data, channels);
3918     if (channel_layout)
3919         bytestream_put_le64(&data, channel_layout);
3920     if (sample_rate)
3921         bytestream_put_le32(&data, sample_rate);
3922     if (width || height) {
3923         bytestream_put_le32(&data, width);
3924         bytestream_put_le32(&data, height);
3925     }
3926     return 0;
3927 }
3928
3929 const struct AVCodecTag *avformat_get_riff_video_tags(void)
3930 {
3931     return ff_codec_bmp_tags;
3932 }
3933 const struct AVCodecTag *avformat_get_riff_audio_tags(void)
3934 {
3935     return ff_codec_wav_tags;
3936 }