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