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