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