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