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