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