dbc8a533f53c4504b19ddc4d6af720ab1df73aa8
[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_MP1 ||
2023              avctx->codec_id == CODEC_ID_MP2 ||
2024              avctx->codec_id == CODEC_ID_MP3 ||
2025              avctx->codec_id == CODEC_ID_CELT))
2026             return 0;
2027         break;
2028     case AVMEDIA_TYPE_VIDEO:
2029         val = avctx->width && avctx->pix_fmt != PIX_FMT_NONE;
2030         break;
2031     default:
2032         val = 1;
2033         break;
2034     }
2035     return avctx->codec_id != CODEC_ID_NONE && val != 0;
2036 }
2037
2038 static int has_decode_delay_been_guessed(AVStream *st)
2039 {
2040     return st->codec->codec_id != CODEC_ID_H264 ||
2041         st->info->nb_decoded_frames >= 6;
2042 }
2043
2044 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2045 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2046 {
2047     AVCodec *codec;
2048     int got_picture = 1, ret = 0;
2049     AVFrame picture;
2050     AVPacket pkt = *avpkt;
2051
2052     if (!avcodec_is_open(st->codec)) {
2053         AVDictionary *thread_opt = NULL;
2054
2055         codec = st->codec->codec ? st->codec->codec :
2056                                    avcodec_find_decoder(st->codec->codec_id);
2057
2058         if (!codec)
2059             return -1;
2060
2061         /* force thread count to 1 since the h264 decoder will not extract SPS
2062          *  and PPS to extradata during multi-threaded decoding */
2063         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2064         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2065         if (!options)
2066             av_dict_free(&thread_opt);
2067         if (ret < 0)
2068             return ret;
2069     }
2070
2071     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2072            ret >= 0 &&
2073            (!has_codec_parameters(st->codec)  ||
2074            !has_decode_delay_been_guessed(st) ||
2075            (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2076         got_picture = 0;
2077         avcodec_get_frame_defaults(&picture);
2078         switch(st->codec->codec_type) {
2079         case AVMEDIA_TYPE_VIDEO:
2080             ret = avcodec_decode_video2(st->codec, &picture,
2081                                         &got_picture, &pkt);
2082             break;
2083         case AVMEDIA_TYPE_AUDIO:
2084             ret = avcodec_decode_audio4(st->codec, &picture, &got_picture, &pkt);
2085             break;
2086         default:
2087             break;
2088         }
2089         if (ret >= 0) {
2090             if (got_picture)
2091                 st->info->nb_decoded_frames++;
2092             pkt.data += ret;
2093             pkt.size -= ret;
2094             ret       = got_picture;
2095         }
2096     }
2097     return ret;
2098 }
2099
2100 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2101 {
2102     while (tags->id != CODEC_ID_NONE) {
2103         if (tags->id == id)
2104             return tags->tag;
2105         tags++;
2106     }
2107     return 0;
2108 }
2109
2110 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2111 {
2112     int i;
2113     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2114         if(tag == tags[i].tag)
2115             return tags[i].id;
2116     }
2117     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2118         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2119             return tags[i].id;
2120     }
2121     return CODEC_ID_NONE;
2122 }
2123
2124 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2125 {
2126     int i;
2127     for(i=0; tags && tags[i]; i++){
2128         int tag= ff_codec_get_tag(tags[i], id);
2129         if(tag) return tag;
2130     }
2131     return 0;
2132 }
2133
2134 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2135 {
2136     int i;
2137     for(i=0; tags && tags[i]; i++){
2138         enum CodecID id= ff_codec_get_id(tags[i], tag);
2139         if(id!=CODEC_ID_NONE) return id;
2140     }
2141     return CODEC_ID_NONE;
2142 }
2143
2144 static void compute_chapters_end(AVFormatContext *s)
2145 {
2146     unsigned int i, j;
2147     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2148
2149     for (i = 0; i < s->nb_chapters; i++)
2150         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2151             AVChapter *ch = s->chapters[i];
2152             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2153                                      : INT64_MAX;
2154
2155             for (j = 0; j < s->nb_chapters; j++) {
2156                 AVChapter *ch1 = s->chapters[j];
2157                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2158                 if (j != i && next_start > ch->start && next_start < end)
2159                     end = next_start;
2160             }
2161             ch->end = (end == INT64_MAX) ? ch->start : end;
2162         }
2163 }
2164
2165 static int get_std_framerate(int i){
2166     if(i<60*12) return i*1001;
2167     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2168 }
2169
2170 /*
2171  * Is the time base unreliable.
2172  * This is a heuristic to balance between quick acceptance of the values in
2173  * the headers vs. some extra checks.
2174  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2175  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2176  * And there are "variable" fps files this needs to detect as well.
2177  */
2178 static int tb_unreliable(AVCodecContext *c){
2179     if(   c->time_base.den >= 101L*c->time_base.num
2180        || c->time_base.den <    5L*c->time_base.num
2181 /*       || c->codec_tag == AV_RL32("DIVX")
2182        || c->codec_tag == AV_RL32("XVID")*/
2183        || c->codec_id == CODEC_ID_MPEG2VIDEO
2184        || c->codec_id == CODEC_ID_H264
2185        )
2186         return 1;
2187     return 0;
2188 }
2189
2190 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2191 {
2192     int i, count, ret, read_size, j;
2193     AVStream *st;
2194     AVPacket pkt1, *pkt;
2195     int64_t old_offset = avio_tell(ic->pb);
2196     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2197
2198     for(i=0;i<ic->nb_streams;i++) {
2199         AVCodec *codec;
2200         AVDictionary *thread_opt = NULL;
2201         st = ic->streams[i];
2202
2203         //only for the split stuff
2204         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2205             st->parser = av_parser_init(st->codec->codec_id);
2206             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2207                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2208             }
2209         }
2210         codec = st->codec->codec ? st->codec->codec :
2211                                    avcodec_find_decoder(st->codec->codec_id);
2212
2213         /* force thread count to 1 since the h264 decoder will not extract SPS
2214          *  and PPS to extradata during multi-threaded decoding */
2215         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2216
2217         /* Ensure that subtitle_header is properly set. */
2218         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2219             && codec && !st->codec->codec)
2220             avcodec_open2(st->codec, codec, options ? &options[i]
2221                               : &thread_opt);
2222
2223         //try to just open decoders, in case this is enough to get parameters
2224         if(!has_codec_parameters(st->codec)){
2225             if (codec && !st->codec->codec)
2226                 avcodec_open2(st->codec, codec, options ? &options[i]
2227                               : &thread_opt);
2228         }
2229         if (!options)
2230             av_dict_free(&thread_opt);
2231     }
2232
2233     for (i=0; i<ic->nb_streams; i++) {
2234         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2235     }
2236
2237     count = 0;
2238     read_size = 0;
2239     for(;;) {
2240         if (ff_check_interrupt(&ic->interrupt_callback)){
2241             ret= AVERROR_EXIT;
2242             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2243             break;
2244         }
2245
2246         /* check if one codec still needs to be handled */
2247         for(i=0;i<ic->nb_streams;i++) {
2248             int fps_analyze_framecount = 20;
2249
2250             st = ic->streams[i];
2251             if (!has_codec_parameters(st->codec))
2252                 break;
2253             /* if the timebase is coarse (like the usual millisecond precision
2254                of mkv), we need to analyze more frames to reliably arrive at
2255                the correct fps */
2256             if (av_q2d(st->time_base) > 0.0005)
2257                 fps_analyze_framecount *= 2;
2258             if (ic->fps_probe_size >= 0)
2259                 fps_analyze_framecount = ic->fps_probe_size;
2260             /* variable fps and no guess at the real fps */
2261             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2262                && st->info->duration_count < fps_analyze_framecount
2263                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2264                 break;
2265             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2266                 break;
2267             if(st->first_dts == AV_NOPTS_VALUE)
2268                 break;
2269         }
2270         if (i == ic->nb_streams) {
2271             /* NOTE: if the format has no header, then we need to read
2272                some packets to get most of the streams, so we cannot
2273                stop here */
2274             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2275                 /* if we found the info for all the codecs, we can stop */
2276                 ret = count;
2277                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2278                 break;
2279             }
2280         }
2281         /* we did not get all the codec info, but we read too much data */
2282         if (read_size >= ic->probesize) {
2283             ret = count;
2284             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2285             break;
2286         }
2287
2288         /* NOTE: a new stream can be added there if no header in file
2289            (AVFMTCTX_NOHEADER) */
2290         ret = read_frame_internal(ic, &pkt1);
2291         if (ret == AVERROR(EAGAIN))
2292             continue;
2293
2294         if (ret < 0) {
2295             /* EOF or error*/
2296             AVPacket empty_pkt = { 0 };
2297             int err;
2298             av_init_packet(&empty_pkt);
2299
2300             ret = -1; /* we could not have all the codec parameters before EOF */
2301             for(i=0;i<ic->nb_streams;i++) {
2302                 st = ic->streams[i];
2303
2304                 /* flush the decoders */
2305                 do {
2306                     err = try_decode_frame(st, &empty_pkt,
2307                                            (options && i < orig_nb_streams) ?
2308                                            &options[i] : NULL);
2309                 } while (err > 0 && !has_codec_parameters(st->codec));
2310
2311                 if (err < 0) {
2312                     av_log(ic, AV_LOG_WARNING,
2313                            "decoding for stream %d failed\n", st->index);
2314                 } else if (!has_codec_parameters(st->codec)){
2315                     char buf[256];
2316                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2317                     av_log(ic, AV_LOG_WARNING,
2318                            "Could not find codec parameters (%s)\n", buf);
2319                 } else {
2320                     ret = 0;
2321                 }
2322             }
2323             break;
2324         }
2325
2326         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2327         if ((ret = av_dup_packet(pkt)) < 0)
2328             goto find_stream_info_err;
2329
2330         read_size += pkt->size;
2331
2332         st = ic->streams[pkt->stream_index];
2333         if (st->codec_info_nb_frames>1) {
2334             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) {
2335                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2336                 break;
2337             }
2338             st->info->codec_info_duration += pkt->duration;
2339         }
2340         {
2341             int64_t last = st->info->last_dts;
2342
2343             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
2344                 int64_t duration= pkt->dts - last;
2345                 double dur= duration * av_q2d(st->time_base);
2346
2347 //                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2348 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2349                 if (st->info->duration_count < 2)
2350                     memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2351                 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2352                     int framerate= get_std_framerate(i);
2353                     int ticks= lrintf(dur*framerate/(1001*12));
2354                     double error = dur - (double)ticks*1001*12 / framerate;
2355                     st->info->duration_error[i] += error*error;
2356                 }
2357                 st->info->duration_count++;
2358                 // ignore the first 4 values, they might have some random jitter
2359                 if (st->info->duration_count > 3)
2360                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2361             }
2362             if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2363                 st->info->last_dts = pkt->dts;
2364         }
2365         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2366             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2367             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2368                 st->codec->extradata_size= i;
2369                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2370                 if (!st->codec->extradata)
2371                     return AVERROR(ENOMEM);
2372                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2373                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2374             }
2375         }
2376
2377         /* if still no information, we try to open the codec and to
2378            decompress the frame. We try to avoid that in most cases as
2379            it takes longer and uses more memory. For MPEG-4, we need to
2380            decompress for QuickTime.
2381
2382            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2383            least one frame of codec data, this makes sure the codec initializes
2384            the channel configuration and does not only trust the values from the container.
2385         */
2386         try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2387
2388         st->codec_info_nb_frames++;
2389         count++;
2390     }
2391
2392     // close codecs which were opened in try_decode_frame()
2393     for(i=0;i<ic->nb_streams;i++) {
2394         st = ic->streams[i];
2395         avcodec_close(st->codec);
2396     }
2397     for(i=0;i<ic->nb_streams;i++) {
2398         st = ic->streams[i];
2399         if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2400             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2401                      (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2402                       st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2403         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2404             // the check for tb_unreliable() is not completely correct, since this is not about handling
2405             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2406             // ipmovie.c produces.
2407             if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2408                 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);
2409             if (st->info->duration_count && !st->r_frame_rate.num
2410                && tb_unreliable(st->codec) /*&&
2411                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2412                st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2413                 int num = 0;
2414                 double best_error= 2*av_q2d(st->time_base);
2415                 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2416
2417                 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2418                     double error = st->info->duration_error[j] * get_std_framerate(j);
2419 //                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2420 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2421                     if(error < best_error){
2422                         best_error= error;
2423                         num = get_std_framerate(j);
2424                     }
2425                 }
2426                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2427                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2428                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2429             }
2430         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2431             if(!st->codec->bits_per_coded_sample)
2432                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2433             // set stream disposition based on audio service type
2434             switch (st->codec->audio_service_type) {
2435             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2436                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2437             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2438                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2439             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2440                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2441             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2442                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2443             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2444                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2445             }
2446         }
2447     }
2448
2449     estimate_timings(ic, old_offset);
2450
2451     compute_chapters_end(ic);
2452
2453 #if 0
2454     /* correct DTS for B-frame streams with no timestamps */
2455     for(i=0;i<ic->nb_streams;i++) {
2456         st = ic->streams[i];
2457         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2458             if(b-frames){
2459                 ppktl = &ic->packet_buffer;
2460                 while(ppkt1){
2461                     if(ppkt1->stream_index != i)
2462                         continue;
2463                     if(ppkt1->pkt->dts < 0)
2464                         break;
2465                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2466                         break;
2467                     ppkt1->pkt->dts -= delta;
2468                     ppkt1= ppkt1->next;
2469                 }
2470                 if(ppkt1)
2471                     continue;
2472                 st->cur_dts -= delta;
2473             }
2474         }
2475     }
2476 #endif
2477
2478  find_stream_info_err:
2479     for (i=0; i < ic->nb_streams; i++) {
2480         if (ic->streams[i]->codec)
2481             ic->streams[i]->codec->thread_count = 0;
2482         av_freep(&ic->streams[i]->info);
2483     }
2484     return ret;
2485 }
2486
2487 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2488 {
2489     int i, j;
2490
2491     for (i = 0; i < ic->nb_programs; i++)
2492         for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2493             if (ic->programs[i]->stream_index[j] == s)
2494                 return ic->programs[i];
2495     return NULL;
2496 }
2497
2498 int av_find_best_stream(AVFormatContext *ic,
2499                         enum AVMediaType type,
2500                         int wanted_stream_nb,
2501                         int related_stream,
2502                         AVCodec **decoder_ret,
2503                         int flags)
2504 {
2505     int i, nb_streams = ic->nb_streams;
2506     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2507     unsigned *program = NULL;
2508     AVCodec *decoder = NULL, *best_decoder = NULL;
2509
2510     if (related_stream >= 0 && wanted_stream_nb < 0) {
2511         AVProgram *p = find_program_from_stream(ic, related_stream);
2512         if (p) {
2513             program = p->stream_index;
2514             nb_streams = p->nb_stream_indexes;
2515         }
2516     }
2517     for (i = 0; i < nb_streams; i++) {
2518         int real_stream_index = program ? program[i] : i;
2519         AVStream *st = ic->streams[real_stream_index];
2520         AVCodecContext *avctx = st->codec;
2521         if (avctx->codec_type != type)
2522             continue;
2523         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2524             continue;
2525         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2526             continue;
2527         if (decoder_ret) {
2528             decoder = avcodec_find_decoder(st->codec->codec_id);
2529             if (!decoder) {
2530                 if (ret < 0)
2531                     ret = AVERROR_DECODER_NOT_FOUND;
2532                 continue;
2533             }
2534         }
2535         if (best_count >= st->codec_info_nb_frames)
2536             continue;
2537         best_count = st->codec_info_nb_frames;
2538         ret = real_stream_index;
2539         best_decoder = decoder;
2540         if (program && i == nb_streams - 1 && ret < 0) {
2541             program = NULL;
2542             nb_streams = ic->nb_streams;
2543             i = 0; /* no related stream found, try again with everything */
2544         }
2545     }
2546     if (decoder_ret)
2547         *decoder_ret = best_decoder;
2548     return ret;
2549 }
2550
2551 /*******************************************************/
2552
2553 int av_read_play(AVFormatContext *s)
2554 {
2555     if (s->iformat->read_play)
2556         return s->iformat->read_play(s);
2557     if (s->pb)
2558         return avio_pause(s->pb, 0);
2559     return AVERROR(ENOSYS);
2560 }
2561
2562 int av_read_pause(AVFormatContext *s)
2563 {
2564     if (s->iformat->read_pause)
2565         return s->iformat->read_pause(s);
2566     if (s->pb)
2567         return avio_pause(s->pb, 1);
2568     return AVERROR(ENOSYS);
2569 }
2570
2571 void avformat_free_context(AVFormatContext *s)
2572 {
2573     int i;
2574     AVStream *st;
2575
2576     av_opt_free(s);
2577     if (s->iformat && s->iformat->priv_class && s->priv_data)
2578         av_opt_free(s->priv_data);
2579
2580     for(i=0;i<s->nb_streams;i++) {
2581         /* free all data in a stream component */
2582         st = s->streams[i];
2583         if (st->parser) {
2584             av_parser_close(st->parser);
2585         }
2586         if (st->attached_pic.data)
2587             av_free_packet(&st->attached_pic);
2588         av_dict_free(&st->metadata);
2589         av_free(st->index_entries);
2590         av_free(st->codec->extradata);
2591         av_free(st->codec->subtitle_header);
2592         av_free(st->codec);
2593         av_free(st->priv_data);
2594         av_free(st->info);
2595         av_free(st);
2596     }
2597     for(i=s->nb_programs-1; i>=0; i--) {
2598         av_dict_free(&s->programs[i]->metadata);
2599         av_freep(&s->programs[i]->stream_index);
2600         av_freep(&s->programs[i]);
2601     }
2602     av_freep(&s->programs);
2603     av_freep(&s->priv_data);
2604     while(s->nb_chapters--) {
2605         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2606         av_free(s->chapters[s->nb_chapters]);
2607     }
2608     av_freep(&s->chapters);
2609     av_dict_free(&s->metadata);
2610     av_freep(&s->streams);
2611     av_free(s);
2612 }
2613
2614 #if FF_API_CLOSE_INPUT_FILE
2615 void av_close_input_file(AVFormatContext *s)
2616 {
2617     avformat_close_input(&s);
2618 }
2619 #endif
2620
2621 void avformat_close_input(AVFormatContext **ps)
2622 {
2623     AVFormatContext *s = *ps;
2624     AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2625                        NULL : s->pb;
2626     flush_packet_queue(s);
2627     if (s->iformat->read_close)
2628         s->iformat->read_close(s);
2629     avformat_free_context(s);
2630     *ps = NULL;
2631     if (pb)
2632         avio_close(pb);
2633 }
2634
2635 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2636 {
2637     AVStream *st;
2638     int i;
2639     AVStream **streams;
2640
2641     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2642         return NULL;
2643     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2644     if (!streams)
2645         return NULL;
2646     s->streams = streams;
2647
2648     st = av_mallocz(sizeof(AVStream));
2649     if (!st)
2650         return NULL;
2651     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2652         av_free(st);
2653         return NULL;
2654     }
2655
2656     st->codec = avcodec_alloc_context3(c);
2657     if (s->iformat) {
2658         /* no default bitrate if decoding */
2659         st->codec->bit_rate = 0;
2660     }
2661     st->index = s->nb_streams;
2662     st->start_time = AV_NOPTS_VALUE;
2663     st->duration = AV_NOPTS_VALUE;
2664         /* we set the current DTS to 0 so that formats without any timestamps
2665            but durations get some timestamps, formats with some unknown
2666            timestamps have their first few packets buffered and the
2667            timestamps corrected before they are returned to the user */
2668     st->cur_dts = 0;
2669     st->first_dts = AV_NOPTS_VALUE;
2670     st->probe_packets = MAX_PROBE_PACKETS;
2671
2672     /* default pts setting is MPEG-like */
2673     avpriv_set_pts_info(st, 33, 1, 90000);
2674     st->last_IP_pts = AV_NOPTS_VALUE;
2675     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2676         st->pts_buffer[i]= AV_NOPTS_VALUE;
2677     st->reference_dts = AV_NOPTS_VALUE;
2678
2679     st->sample_aspect_ratio = (AVRational){0,1};
2680
2681     s->streams[s->nb_streams++] = st;
2682     return st;
2683 }
2684
2685 AVProgram *av_new_program(AVFormatContext *ac, int id)
2686 {
2687     AVProgram *program=NULL;
2688     int i;
2689
2690     av_dlog(ac, "new_program: id=0x%04x\n", id);
2691
2692     for(i=0; i<ac->nb_programs; i++)
2693         if(ac->programs[i]->id == id)
2694             program = ac->programs[i];
2695
2696     if(!program){
2697         program = av_mallocz(sizeof(AVProgram));
2698         if (!program)
2699             return NULL;
2700         dynarray_add(&ac->programs, &ac->nb_programs, program);
2701         program->discard = AVDISCARD_NONE;
2702     }
2703     program->id = id;
2704
2705     return program;
2706 }
2707
2708 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2709 {
2710     AVChapter *chapter = NULL;
2711     int i;
2712
2713     for(i=0; i<s->nb_chapters; i++)
2714         if(s->chapters[i]->id == id)
2715             chapter = s->chapters[i];
2716
2717     if(!chapter){
2718         chapter= av_mallocz(sizeof(AVChapter));
2719         if(!chapter)
2720             return NULL;
2721         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2722     }
2723     av_dict_set(&chapter->metadata, "title", title, 0);
2724     chapter->id    = id;
2725     chapter->time_base= time_base;
2726     chapter->start = start;
2727     chapter->end   = end;
2728
2729     return chapter;
2730 }
2731
2732 /************************************************************/
2733 /* output media file */
2734
2735 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2736 {
2737     const AVCodecTag *avctag;
2738     int n;
2739     enum CodecID id = CODEC_ID_NONE;
2740     unsigned int tag = 0;
2741
2742     /**
2743      * Check that tag + id is in the table
2744      * If neither is in the table -> OK
2745      * If tag is in the table with another id -> FAIL
2746      * If id is in the table with another tag -> FAIL unless strict < normal
2747      */
2748     for (n = 0; s->oformat->codec_tag[n]; n++) {
2749         avctag = s->oformat->codec_tag[n];
2750         while (avctag->id != CODEC_ID_NONE) {
2751             if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
2752                 id = avctag->id;
2753                 if (id == st->codec->codec_id)
2754                     return 1;
2755             }
2756             if (avctag->id == st->codec->codec_id)
2757                 tag = avctag->tag;
2758             avctag++;
2759         }
2760     }
2761     if (id != CODEC_ID_NONE)
2762         return 0;
2763     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2764         return 0;
2765     return 1;
2766 }
2767
2768 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2769 {
2770     int ret = 0, i;
2771     AVStream *st;
2772     AVDictionary *tmp = NULL;
2773
2774     if (options)
2775         av_dict_copy(&tmp, *options, 0);
2776     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2777         goto fail;
2778
2779     // some sanity checks
2780     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2781         av_log(s, AV_LOG_ERROR, "no streams\n");
2782         ret = AVERROR(EINVAL);
2783         goto fail;
2784     }
2785
2786     for(i=0;i<s->nb_streams;i++) {
2787         st = s->streams[i];
2788
2789         switch (st->codec->codec_type) {
2790         case AVMEDIA_TYPE_AUDIO:
2791             if(st->codec->sample_rate<=0){
2792                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2793                 ret = AVERROR(EINVAL);
2794                 goto fail;
2795             }
2796             if(!st->codec->block_align)
2797                 st->codec->block_align = st->codec->channels *
2798                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2799             break;
2800         case AVMEDIA_TYPE_VIDEO:
2801             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2802                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2803                 ret = AVERROR(EINVAL);
2804                 goto fail;
2805             }
2806             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2807                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2808                 ret = AVERROR(EINVAL);
2809                 goto fail;
2810             }
2811             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2812                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
2813                        "(%d/%d) and encoder layer (%d/%d)\n",
2814                        st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2815                        st->codec->sample_aspect_ratio.num,
2816                        st->codec->sample_aspect_ratio.den);
2817                 ret = AVERROR(EINVAL);
2818                 goto fail;
2819             }
2820             break;
2821         }
2822
2823         if(s->oformat->codec_tag){
2824             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)){
2825                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2826                 st->codec->codec_tag= 0;
2827             }
2828             if(st->codec->codec_tag){
2829                 if (!validate_codec_tag(s, st)) {
2830                     char tagbuf[32];
2831                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2832                     av_log(s, AV_LOG_ERROR,
2833                            "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2834                            tagbuf, st->codec->codec_tag, st->codec->codec_id);
2835                     ret = AVERROR_INVALIDDATA;
2836                     goto fail;
2837                 }
2838             }else
2839                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2840         }
2841
2842         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2843             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2844           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2845     }
2846
2847     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2848         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2849         if (!s->priv_data) {
2850             ret = AVERROR(ENOMEM);
2851             goto fail;
2852         }
2853         if (s->oformat->priv_class) {
2854             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2855             av_opt_set_defaults(s->priv_data);
2856             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2857                 goto fail;
2858         }
2859     }
2860
2861     /* set muxer identification string */
2862     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2863         av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2864     }
2865
2866     if(s->oformat->write_header){
2867         ret = s->oformat->write_header(s);
2868         if (ret < 0)
2869             goto fail;
2870     }
2871
2872     /* init PTS generation */
2873     for(i=0;i<s->nb_streams;i++) {
2874         int64_t den = AV_NOPTS_VALUE;
2875         st = s->streams[i];
2876
2877         switch (st->codec->codec_type) {
2878         case AVMEDIA_TYPE_AUDIO:
2879             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2880             break;
2881         case AVMEDIA_TYPE_VIDEO:
2882             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2883             break;
2884         default:
2885             break;
2886         }
2887         if (den != AV_NOPTS_VALUE) {
2888             if (den <= 0) {
2889                 ret = AVERROR_INVALIDDATA;
2890                 goto fail;
2891             }
2892             frac_init(&st->pts, 0, 0, den);
2893         }
2894     }
2895
2896     if (options) {
2897         av_dict_free(options);
2898         *options = tmp;
2899     }
2900     return 0;
2901 fail:
2902     av_dict_free(&tmp);
2903     return ret;
2904 }
2905
2906 //FIXME merge with compute_pkt_fields
2907 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2908     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2909     int num, den, frame_size, i;
2910
2911     av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2912             pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2913
2914 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2915         return AVERROR(EINVAL);*/
2916
2917     /* duration field */
2918     if (pkt->duration == 0) {
2919         compute_frame_duration(&num, &den, st, NULL, pkt);
2920         if (den && num) {
2921             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2922         }
2923     }
2924
2925     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2926         pkt->pts= pkt->dts;
2927
2928     //XXX/FIXME this is a temporary hack until all encoders output pts
2929     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2930         pkt->dts=
2931 //        pkt->pts= st->cur_dts;
2932         pkt->pts= st->pts.val;
2933     }
2934
2935     //calculate dts from pts
2936     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2937         st->pts_buffer[0]= pkt->pts;
2938         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2939             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2940         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2941             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2942
2943         pkt->dts= st->pts_buffer[0];
2944     }
2945
2946     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2947         av_log(s, AV_LOG_ERROR,
2948                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2949                st->index, st->cur_dts, pkt->dts);
2950         return AVERROR(EINVAL);
2951     }
2952     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2953         av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2954         return AVERROR(EINVAL);
2955     }
2956
2957 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2958     st->cur_dts= pkt->dts;
2959     st->pts.val= pkt->dts;
2960
2961     /* update pts */
2962     switch (st->codec->codec_type) {
2963     case AVMEDIA_TYPE_AUDIO:
2964         frame_size = get_audio_frame_size(st->codec, pkt->size);
2965
2966         /* HACK/FIXME, we skip the initial 0 size packets as they are most
2967            likely equal to the encoder delay, but it would be better if we
2968            had the real timestamps from the encoder */
2969         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2970             frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2971         }
2972         break;
2973     case AVMEDIA_TYPE_VIDEO:
2974         frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2975         break;
2976     default:
2977         break;
2978     }
2979     return 0;
2980 }
2981
2982 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2983 {
2984     int ret;
2985
2986     if (!pkt) {
2987         if (s->oformat->flags & AVFMT_ALLOW_FLUSH)
2988             return s->oformat->write_packet(s, pkt);
2989         return 1;
2990     }
2991
2992     ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2993
2994     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2995         return ret;
2996
2997     ret= s->oformat->write_packet(s, pkt);
2998
2999     if (ret >= 0)
3000         s->streams[pkt->stream_index]->nb_frames++;
3001     return ret;
3002 }
3003
3004 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3005                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3006 {
3007     AVPacketList **next_point, *this_pktl;
3008
3009     this_pktl = av_mallocz(sizeof(AVPacketList));
3010     this_pktl->pkt= *pkt;
3011     pkt->destruct= NULL;             // do not free original but only the copy
3012     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3013
3014     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3015         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3016     }else
3017         next_point = &s->packet_buffer;
3018
3019     if(*next_point){
3020         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3021             while(!compare(s, &(*next_point)->pkt, pkt)){
3022                 next_point= &(*next_point)->next;
3023             }
3024             goto next_non_null;
3025         }else{
3026             next_point = &(s->packet_buffer_end->next);
3027         }
3028     }
3029     assert(!*next_point);
3030
3031     s->packet_buffer_end= this_pktl;
3032 next_non_null:
3033
3034     this_pktl->next= *next_point;
3035
3036     s->streams[pkt->stream_index]->last_in_packet_buffer=
3037     *next_point= this_pktl;
3038 }
3039
3040 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3041 {
3042     AVStream *st = s->streams[ pkt ->stream_index];
3043     AVStream *st2= s->streams[ next->stream_index];
3044     int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3045                              st->time_base);
3046
3047     if (comp == 0)
3048         return pkt->stream_index < next->stream_index;
3049     return comp > 0;
3050 }
3051
3052 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3053     AVPacketList *pktl;
3054     int stream_count=0;
3055     int i;
3056
3057     if(pkt){
3058         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3059     }
3060
3061     for(i=0; i < s->nb_streams; i++)
3062         stream_count+= !!s->streams[i]->last_in_packet_buffer;
3063
3064     if(stream_count && (s->nb_streams == stream_count || flush)){
3065         pktl= s->packet_buffer;
3066         *out= pktl->pkt;
3067
3068         s->packet_buffer= pktl->next;
3069         if(!s->packet_buffer)
3070             s->packet_buffer_end= NULL;
3071
3072         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3073             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3074         av_freep(&pktl);
3075         return 1;
3076     }else{
3077         av_init_packet(out);
3078         return 0;
3079     }
3080 }
3081
3082 /**
3083  * Interleave an AVPacket correctly so it can be muxed.
3084  * @param out the interleaved packet will be output here
3085  * @param in the input packet
3086  * @param flush 1 if no further packets are available as input and all
3087  *              remaining packets should be output
3088  * @return 1 if a packet was output, 0 if no packet could be output,
3089  *         < 0 if an error occurred
3090  */
3091 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3092     if (s->oformat->interleave_packet) {
3093         int ret = s->oformat->interleave_packet(s, out, in, flush);
3094         if (in)
3095             av_free_packet(in);
3096         return ret;
3097     } else
3098         return av_interleave_packet_per_dts(s, out, in, flush);
3099 }
3100
3101 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3102     AVStream *st= s->streams[ pkt->stream_index];
3103     int ret;
3104
3105     //FIXME/XXX/HACK drop zero sized packets
3106     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3107         return 0;
3108
3109     av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3110             pkt->size, pkt->dts, pkt->pts);
3111     if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3112         return ret;
3113
3114     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3115         return AVERROR(EINVAL);
3116
3117     for(;;){
3118         AVPacket opkt;
3119         int ret= interleave_packet(s, &opkt, pkt, 0);
3120         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3121             return ret;
3122
3123         ret= s->oformat->write_packet(s, &opkt);
3124         if (ret >= 0)
3125             s->streams[opkt.stream_index]->nb_frames++;
3126
3127         av_free_packet(&opkt);
3128         pkt= NULL;
3129
3130         if(ret<0)
3131             return ret;
3132     }
3133 }
3134
3135 int av_write_trailer(AVFormatContext *s)
3136 {
3137     int ret, i;
3138
3139     for(;;){
3140         AVPacket pkt;
3141         ret= interleave_packet(s, &pkt, NULL, 1);
3142         if(ret<0) //FIXME cleanup needed for ret<0 ?
3143             goto fail;
3144         if(!ret)
3145             break;
3146
3147         ret= s->oformat->write_packet(s, &pkt);
3148         if (ret >= 0)
3149             s->streams[pkt.stream_index]->nb_frames++;
3150
3151         av_free_packet(&pkt);
3152
3153         if(ret<0)
3154             goto fail;
3155     }
3156
3157     if(s->oformat->write_trailer)
3158         ret = s->oformat->write_trailer(s);
3159 fail:
3160     for(i=0;i<s->nb_streams;i++) {
3161         av_freep(&s->streams[i]->priv_data);
3162         av_freep(&s->streams[i]->index_entries);
3163     }
3164     if (s->oformat->priv_class)
3165         av_opt_free(s->priv_data);
3166     av_freep(&s->priv_data);
3167     return ret;
3168 }
3169
3170 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3171 {
3172     int i, j;
3173     AVProgram *program=NULL;
3174     void *tmp;
3175
3176     if (idx >= ac->nb_streams) {
3177         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3178         return;
3179     }
3180
3181     for(i=0; i<ac->nb_programs; i++){
3182         if(ac->programs[i]->id != progid)
3183             continue;
3184         program = ac->programs[i];
3185         for(j=0; j<program->nb_stream_indexes; j++)
3186             if(program->stream_index[j] == idx)
3187                 return;
3188
3189         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3190         if(!tmp)
3191             return;
3192         program->stream_index = tmp;
3193         program->stream_index[program->nb_stream_indexes++] = idx;
3194         return;
3195     }
3196 }
3197
3198 static void print_fps(double d, const char *postfix){
3199     uint64_t v= lrintf(d*100);
3200     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3201     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3202     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3203 }
3204
3205 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3206 {
3207     if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3208         AVDictionaryEntry *tag=NULL;
3209
3210         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3211         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3212             if(strcmp("language", tag->key))
3213                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3214         }
3215     }
3216 }
3217
3218 /* "user interface" functions */
3219 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3220 {
3221     char buf[256];
3222     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3223     AVStream *st = ic->streams[i];
3224     int g = av_gcd(st->time_base.num, st->time_base.den);
3225     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3226     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3227     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3228     /* the pid is an important information, so we display it */
3229     /* XXX: add a generic system */
3230     if (flags & AVFMT_SHOW_IDS)
3231         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3232     if (lang)
3233         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3234     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3235     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3236     if (st->sample_aspect_ratio.num && // default
3237         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3238         AVRational display_aspect_ratio;
3239         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3240                   st->codec->width*st->sample_aspect_ratio.num,
3241                   st->codec->height*st->sample_aspect_ratio.den,
3242                   1024*1024);
3243         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3244                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3245                  display_aspect_ratio.num, display_aspect_ratio.den);
3246     }
3247     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3248         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3249             print_fps(av_q2d(st->avg_frame_rate), "fps");
3250         if(st->r_frame_rate.den && st->r_frame_rate.num)
3251             print_fps(av_q2d(st->r_frame_rate), "tbr");
3252         if(st->time_base.den && st->time_base.num)
3253             print_fps(1/av_q2d(st->time_base), "tbn");
3254         if(st->codec->time_base.den && st->codec->time_base.num)
3255             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3256     }
3257     if (st->disposition & AV_DISPOSITION_DEFAULT)
3258         av_log(NULL, AV_LOG_INFO, " (default)");
3259     if (st->disposition & AV_DISPOSITION_DUB)
3260         av_log(NULL, AV_LOG_INFO, " (dub)");
3261     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3262         av_log(NULL, AV_LOG_INFO, " (original)");
3263     if (st->disposition & AV_DISPOSITION_COMMENT)
3264         av_log(NULL, AV_LOG_INFO, " (comment)");
3265     if (st->disposition & AV_DISPOSITION_LYRICS)
3266         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3267     if (st->disposition & AV_DISPOSITION_KARAOKE)
3268         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3269     if (st->disposition & AV_DISPOSITION_FORCED)
3270         av_log(NULL, AV_LOG_INFO, " (forced)");
3271     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3272         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3273     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3274         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3275     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3276         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3277     av_log(NULL, AV_LOG_INFO, "\n");
3278     dump_metadata(NULL, st->metadata, "    ");
3279 }
3280
3281 void av_dump_format(AVFormatContext *ic,
3282                     int index,
3283                     const char *url,
3284                     int is_output)
3285 {
3286     int i;
3287     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3288     if (ic->nb_streams && !printed)
3289         return;
3290
3291     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3292             is_output ? "Output" : "Input",
3293             index,
3294             is_output ? ic->oformat->name : ic->iformat->name,
3295             is_output ? "to" : "from", url);
3296     dump_metadata(NULL, ic->metadata, "  ");
3297     if (!is_output) {
3298         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3299         if (ic->duration != AV_NOPTS_VALUE) {
3300             int hours, mins, secs, us;
3301             secs = ic->duration / AV_TIME_BASE;
3302             us = ic->duration % AV_TIME_BASE;
3303             mins = secs / 60;
3304             secs %= 60;
3305             hours = mins / 60;
3306             mins %= 60;
3307             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3308                    (100 * us) / AV_TIME_BASE);
3309         } else {
3310             av_log(NULL, AV_LOG_INFO, "N/A");
3311         }
3312         if (ic->start_time != AV_NOPTS_VALUE) {
3313             int secs, us;
3314             av_log(NULL, AV_LOG_INFO, ", start: ");
3315             secs = ic->start_time / AV_TIME_BASE;
3316             us = abs(ic->start_time % AV_TIME_BASE);
3317             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3318                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3319         }
3320         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3321         if (ic->bit_rate) {
3322             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3323         } else {
3324             av_log(NULL, AV_LOG_INFO, "N/A");
3325         }
3326         av_log(NULL, AV_LOG_INFO, "\n");
3327     }
3328     for (i = 0; i < ic->nb_chapters; i++) {
3329         AVChapter *ch = ic->chapters[i];
3330         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3331         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3332         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3333
3334         dump_metadata(NULL, ch->metadata, "    ");
3335     }
3336     if(ic->nb_programs) {
3337         int j, k, total = 0;
3338         for(j=0; j<ic->nb_programs; j++) {
3339             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3340                                                   "name", NULL, 0);
3341             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3342                    name ? name->value : "");
3343             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3344             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3345                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3346                 printed[ic->programs[j]->stream_index[k]] = 1;
3347             }
3348             total += ic->programs[j]->nb_stream_indexes;
3349         }
3350         if (total < ic->nb_streams)
3351             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3352     }
3353     for(i=0;i<ic->nb_streams;i++)
3354         if (!printed[i])
3355             dump_stream_format(ic, i, index, is_output);
3356
3357     av_free(printed);
3358 }
3359
3360 int64_t av_gettime(void)
3361 {
3362     struct timeval tv;
3363     gettimeofday(&tv,NULL);
3364     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3365 }
3366
3367 uint64_t ff_ntp_time(void)
3368 {
3369   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3370 }
3371
3372 int av_get_frame_filename(char *buf, int buf_size,
3373                           const char *path, int number)
3374 {
3375     const char *p;
3376     char *q, buf1[20], c;
3377     int nd, len, percentd_found;
3378
3379     q = buf;
3380     p = path;
3381     percentd_found = 0;
3382     for(;;) {
3383         c = *p++;
3384         if (c == '\0')
3385             break;
3386         if (c == '%') {
3387             do {
3388                 nd = 0;
3389                 while (isdigit(*p)) {
3390                     nd = nd * 10 + *p++ - '0';
3391                 }
3392                 c = *p++;
3393             } while (isdigit(c));
3394
3395             switch(c) {
3396             case '%':
3397                 goto addchar;
3398             case 'd':
3399                 if (percentd_found)
3400                     goto fail;
3401                 percentd_found = 1;
3402                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3403                 len = strlen(buf1);
3404                 if ((q - buf + len) > buf_size - 1)
3405                     goto fail;
3406                 memcpy(q, buf1, len);
3407                 q += len;
3408                 break;
3409             default:
3410                 goto fail;
3411             }
3412         } else {
3413         addchar:
3414             if ((q - buf) < buf_size - 1)
3415                 *q++ = c;
3416         }
3417     }
3418     if (!percentd_found)
3419         goto fail;
3420     *q = '\0';
3421     return 0;
3422  fail:
3423     *q = '\0';
3424     return -1;
3425 }
3426
3427 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3428 {
3429     int len, i, j, c;
3430 #undef fprintf
3431 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3432
3433     for(i=0;i<size;i+=16) {
3434         len = size - i;
3435         if (len > 16)
3436             len = 16;
3437         PRINT("%08x ", i);
3438         for(j=0;j<16;j++) {
3439             if (j < len)
3440                 PRINT(" %02x", buf[i+j]);
3441             else
3442                 PRINT("   ");
3443         }
3444         PRINT(" ");
3445         for(j=0;j<len;j++) {
3446             c = buf[i+j];
3447             if (c < ' ' || c > '~')
3448                 c = '.';
3449             PRINT("%c", c);
3450         }
3451         PRINT("\n");
3452     }
3453 #undef PRINT
3454 }
3455
3456 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3457 {
3458     hex_dump_internal(NULL, f, 0, buf, size);
3459 }
3460
3461 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3462 {
3463     hex_dump_internal(avcl, NULL, level, buf, size);
3464 }
3465
3466 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3467 {
3468 #undef fprintf
3469 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3470     PRINT("stream #%d:\n", pkt->stream_index);
3471     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3472     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3473     /* DTS is _always_ valid after av_read_frame() */
3474     PRINT("  dts=");
3475     if (pkt->dts == AV_NOPTS_VALUE)
3476         PRINT("N/A");
3477     else
3478         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3479     /* PTS may not be known if B-frames are present. */
3480     PRINT("  pts=");
3481     if (pkt->pts == AV_NOPTS_VALUE)
3482         PRINT("N/A");
3483     else
3484         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3485     PRINT("\n");
3486     PRINT("  size=%d\n", pkt->size);
3487 #undef PRINT
3488     if (dump_payload)
3489         av_hex_dump(f, pkt->data, pkt->size);
3490 }
3491
3492 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3493 {
3494     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3495 }
3496
3497 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3498                       AVStream *st)
3499 {
3500     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3501 }
3502
3503 void av_url_split(char *proto, int proto_size,
3504                   char *authorization, int authorization_size,
3505                   char *hostname, int hostname_size,
3506                   int *port_ptr,
3507                   char *path, int path_size,
3508                   const char *url)
3509 {
3510     const char *p, *ls, *at, *col, *brk;
3511
3512     if (port_ptr)               *port_ptr = -1;
3513     if (proto_size > 0)         proto[0] = 0;
3514     if (authorization_size > 0) authorization[0] = 0;
3515     if (hostname_size > 0)      hostname[0] = 0;
3516     if (path_size > 0)          path[0] = 0;
3517
3518     /* parse protocol */
3519     if ((p = strchr(url, ':'))) {
3520         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3521         p++; /* skip ':' */
3522         if (*p == '/') p++;
3523         if (*p == '/') p++;
3524     } else {
3525         /* no protocol means plain filename */
3526         av_strlcpy(path, url, path_size);
3527         return;
3528     }
3529
3530     /* separate path from hostname */
3531     ls = strchr(p, '/');
3532     if(!ls)
3533         ls = strchr(p, '?');
3534     if(ls)
3535         av_strlcpy(path, ls, path_size);
3536     else
3537         ls = &p[strlen(p)]; // XXX
3538
3539     /* the rest is hostname, use that to parse auth/port */
3540     if (ls != p) {
3541         /* authorization (user[:pass]@hostname) */
3542         if ((at = strchr(p, '@')) && at < ls) {
3543             av_strlcpy(authorization, p,
3544                        FFMIN(authorization_size, at + 1 - p));
3545             p = at + 1; /* skip '@' */
3546         }
3547
3548         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3549             /* [host]:port */
3550             av_strlcpy(hostname, p + 1,
3551                        FFMIN(hostname_size, brk - p));
3552             if (brk[1] == ':' && port_ptr)
3553                 *port_ptr = atoi(brk + 2);
3554         } else if ((col = strchr(p, ':')) && col < ls) {
3555             av_strlcpy(hostname, p,
3556                        FFMIN(col + 1 - p, hostname_size));
3557             if (port_ptr) *port_ptr = atoi(col + 1);
3558         } else
3559             av_strlcpy(hostname, p,
3560                        FFMIN(ls + 1 - p, hostname_size));
3561     }
3562 }
3563
3564 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3565 {
3566     int i;
3567     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3568                                            '4', '5', '6', '7',
3569                                            '8', '9', 'A', 'B',
3570                                            'C', 'D', 'E', 'F' };
3571     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3572                                            '4', '5', '6', '7',
3573                                            '8', '9', 'a', 'b',
3574                                            'c', 'd', 'e', 'f' };
3575     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3576
3577     for(i = 0; i < s; i++) {
3578         buff[i * 2]     = hex_table[src[i] >> 4];
3579         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3580     }
3581
3582     return buff;
3583 }
3584
3585 int ff_hex_to_data(uint8_t *data, const char *p)
3586 {
3587     int c, len, v;
3588
3589     len = 0;
3590     v = 1;
3591     for (;;) {
3592         p += strspn(p, SPACE_CHARS);
3593         if (*p == '\0')
3594             break;
3595         c = toupper((unsigned char) *p++);
3596         if (c >= '0' && c <= '9')
3597             c = c - '0';
3598         else if (c >= 'A' && c <= 'F')
3599             c = c - 'A' + 10;
3600         else
3601             break;
3602         v = (v << 4) | c;
3603         if (v & 0x100) {
3604             if (data)
3605                 data[len] = v;
3606             len++;
3607             v = 1;
3608         }
3609     }
3610     return len;
3611 }
3612
3613 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3614                          unsigned int pts_num, unsigned int pts_den)
3615 {
3616     AVRational new_tb;
3617     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3618         if(new_tb.num != pts_num)
3619             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3620     }else
3621         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3622
3623     if(new_tb.num <= 0 || new_tb.den <= 0) {
3624         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3625         return;
3626     }
3627     s->time_base = new_tb;
3628     s->pts_wrap_bits = pts_wrap_bits;
3629 }
3630
3631 int ff_url_join(char *str, int size, const char *proto,
3632                 const char *authorization, const char *hostname,
3633                 int port, const char *fmt, ...)
3634 {
3635 #if CONFIG_NETWORK
3636     struct addrinfo hints, *ai;
3637 #endif
3638
3639     str[0] = '\0';
3640     if (proto)
3641         av_strlcatf(str, size, "%s://", proto);
3642     if (authorization && authorization[0])
3643         av_strlcatf(str, size, "%s@", authorization);
3644 #if CONFIG_NETWORK && defined(AF_INET6)
3645     /* Determine if hostname is a numerical IPv6 address,
3646      * properly escape it within [] in that case. */
3647     memset(&hints, 0, sizeof(hints));
3648     hints.ai_flags = AI_NUMERICHOST;
3649     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3650         if (ai->ai_family == AF_INET6) {
3651             av_strlcat(str, "[", size);
3652             av_strlcat(str, hostname, size);
3653             av_strlcat(str, "]", size);
3654         } else {
3655             av_strlcat(str, hostname, size);
3656         }
3657         freeaddrinfo(ai);
3658     } else
3659 #endif
3660         /* Not an IPv6 address, just output the plain string. */
3661         av_strlcat(str, hostname, size);
3662
3663     if (port >= 0)
3664         av_strlcatf(str, size, ":%d", port);
3665     if (fmt) {
3666         va_list vl;
3667         int len = strlen(str);
3668
3669         va_start(vl, fmt);
3670         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3671         va_end(vl);
3672     }
3673     return strlen(str);
3674 }
3675
3676 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3677                      AVFormatContext *src)
3678 {
3679     AVPacket local_pkt;
3680
3681     local_pkt = *pkt;
3682     local_pkt.stream_index = dst_stream;
3683     if (pkt->pts != AV_NOPTS_VALUE)
3684         local_pkt.pts = av_rescale_q(pkt->pts,
3685                                      src->streams[pkt->stream_index]->time_base,
3686                                      dst->streams[dst_stream]->time_base);
3687     if (pkt->dts != AV_NOPTS_VALUE)
3688         local_pkt.dts = av_rescale_q(pkt->dts,
3689                                      src->streams[pkt->stream_index]->time_base,
3690                                      dst->streams[dst_stream]->time_base);
3691     return av_write_frame(dst, &local_pkt);
3692 }
3693
3694 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3695                         void *context)
3696 {
3697     const char *ptr = str;
3698
3699     /* Parse key=value pairs. */
3700     for (;;) {
3701         const char *key;
3702         char *dest = NULL, *dest_end;
3703         int key_len, dest_len = 0;
3704
3705         /* Skip whitespace and potential commas. */
3706         while (*ptr && (isspace(*ptr) || *ptr == ','))
3707             ptr++;
3708         if (!*ptr)
3709             break;
3710
3711         key = ptr;
3712
3713         if (!(ptr = strchr(key, '=')))
3714             break;
3715         ptr++;
3716         key_len = ptr - key;
3717
3718         callback_get_buf(context, key, key_len, &dest, &dest_len);
3719         dest_end = dest + dest_len - 1;
3720
3721         if (*ptr == '\"') {
3722             ptr++;
3723             while (*ptr && *ptr != '\"') {
3724                 if (*ptr == '\\') {
3725                     if (!ptr[1])
3726                         break;
3727                     if (dest && dest < dest_end)
3728                         *dest++ = ptr[1];
3729                     ptr += 2;
3730                 } else {
3731                     if (dest && dest < dest_end)
3732                         *dest++ = *ptr;
3733                     ptr++;
3734                 }
3735             }
3736             if (*ptr == '\"')
3737                 ptr++;
3738         } else {
3739             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3740                 if (dest && dest < dest_end)
3741                     *dest++ = *ptr;
3742         }
3743         if (dest)
3744             *dest = 0;
3745     }
3746 }
3747
3748 int ff_find_stream_index(AVFormatContext *s, int id)
3749 {
3750     int i;
3751     for (i = 0; i < s->nb_streams; i++) {
3752         if (s->streams[i]->id == id)
3753             return i;
3754     }
3755     return -1;
3756 }
3757
3758 void ff_make_absolute_url(char *buf, int size, const char *base,
3759                           const char *rel)
3760 {
3761     char *sep;
3762     /* Absolute path, relative to the current server */
3763     if (base && strstr(base, "://") && rel[0] == '/') {
3764         if (base != buf)
3765             av_strlcpy(buf, base, size);
3766         sep = strstr(buf, "://");
3767         if (sep) {
3768             sep += 3;
3769             sep = strchr(sep, '/');
3770             if (sep)
3771                 *sep = '\0';
3772         }
3773         av_strlcat(buf, rel, size);
3774         return;
3775     }
3776     /* If rel actually is an absolute url, just copy it */
3777     if (!base || strstr(rel, "://") || rel[0] == '/') {
3778         av_strlcpy(buf, rel, size);
3779         return;
3780     }
3781     if (base != buf)
3782         av_strlcpy(buf, base, size);
3783     /* Remove the file name from the base url */
3784     sep = strrchr(buf, '/');
3785     if (sep)
3786         sep[1] = '\0';
3787     else
3788         buf[0] = '\0';
3789     while (av_strstart(rel, "../", NULL) && sep) {
3790         /* Remove the path delimiter at the end */
3791         sep[0] = '\0';
3792         sep = strrchr(buf, '/');
3793         /* If the next directory name to pop off is "..", break here */
3794         if (!strcmp(sep ? &sep[1] : buf, "..")) {
3795             /* Readd the slash we just removed */
3796             av_strlcat(buf, "/", size);
3797             break;
3798         }
3799         /* Cut off the directory name */
3800         if (sep)
3801             sep[1] = '\0';
3802         else
3803             buf[0] = '\0';
3804         rel += 3;
3805     }
3806     av_strlcat(buf, rel, size);
3807 }
3808
3809 int64_t ff_iso8601_to_unix_time(const char *datestr)
3810 {
3811 #if HAVE_STRPTIME
3812     struct tm time1 = {0}, time2 = {0};
3813     char *ret1, *ret2;
3814     ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
3815     ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
3816     if (ret2 && !ret1)
3817         return av_timegm(&time2);
3818     else
3819         return av_timegm(&time1);
3820 #else
3821     av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
3822                                  "the date string.\n");
3823     return 0;
3824 #endif
3825 }
3826
3827 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
3828 {
3829     if (ofmt) {
3830         if (ofmt->query_codec)
3831             return ofmt->query_codec(codec_id, std_compliance);
3832         else if (ofmt->codec_tag)
3833             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
3834         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
3835                  codec_id == ofmt->subtitle_codec)
3836             return 1;
3837     }
3838     return AVERROR_PATCHWELCOME;
3839 }
3840
3841 int avformat_network_init(void)
3842 {
3843 #if CONFIG_NETWORK
3844     int ret;
3845     ff_network_inited_globally = 1;
3846     if ((ret = ff_network_init()) < 0)
3847         return ret;
3848     ff_tls_init();
3849 #endif
3850     return 0;
3851 }
3852
3853 int avformat_network_deinit(void)
3854 {
3855 #if CONFIG_NETWORK
3856     ff_network_close();
3857     ff_tls_deinit();
3858 #endif
3859     return 0;
3860 }
3861
3862 int ff_add_param_change(AVPacket *pkt, int32_t channels,
3863                         uint64_t channel_layout, int32_t sample_rate,
3864                         int32_t width, int32_t height)
3865 {
3866     uint32_t flags = 0;
3867     int size = 4;
3868     uint8_t *data;
3869     if (!pkt)
3870         return AVERROR(EINVAL);
3871     if (channels) {
3872         size += 4;
3873         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
3874     }
3875     if (channel_layout) {
3876         size += 8;
3877         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
3878     }
3879     if (sample_rate) {
3880         size += 4;
3881         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
3882     }
3883     if (width || height) {
3884         size += 8;
3885         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
3886     }
3887     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
3888     if (!data)
3889         return AVERROR(ENOMEM);
3890     bytestream_put_le32(&data, flags);
3891     if (channels)
3892         bytestream_put_le32(&data, channels);
3893     if (channel_layout)
3894         bytestream_put_le64(&data, channel_layout);
3895     if (sample_rate)
3896         bytestream_put_le32(&data, sample_rate);
3897     if (width || height) {
3898         bytestream_put_le32(&data, width);
3899         bytestream_put_le32(&data, height);
3900     }
3901     return 0;
3902 }
3903
3904 const struct AVCodecTag *avformat_get_riff_video_tags(void)
3905 {
3906     return ff_codec_bmp_tags;
3907 }
3908 const struct AVCodecTag *avformat_get_riff_audio_tags(void)
3909 {
3910     return ff_codec_wav_tags;
3911 }