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