deal with the case where one of pts,dts has wrapped but the other has not
[ffmpeg.git] / libavformat / utils.c
1 /*
2  * Various utilities for ffmpeg system
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg 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  * FFmpeg 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 FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 #include "avformat.h"
22 #include "allformats.h"
23 #include "opt.h"
24 #include "avstring.h"
25 #include "riff.h"
26 #include <sys/time.h>
27 #include <time.h>
28
29 #undef NDEBUG
30 #include <assert.h>
31
32 /**
33  * @file libavformat/utils.c
34  * Various utility functions for using ffmpeg library.
35  */
36
37 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
38 static void av_frac_add(AVFrac *f, int64_t incr);
39
40 /** head of registered input format linked list. */
41 AVInputFormat *first_iformat = NULL;
42 /** head of registered output format linked list. */
43 AVOutputFormat *first_oformat = NULL;
44
45 void av_register_input_format(AVInputFormat *format)
46 {
47     AVInputFormat **p;
48     p = &first_iformat;
49     while (*p != NULL) p = &(*p)->next;
50     *p = format;
51     format->next = NULL;
52 }
53
54 void av_register_output_format(AVOutputFormat *format)
55 {
56     AVOutputFormat **p;
57     p = &first_oformat;
58     while (*p != NULL) p = &(*p)->next;
59     *p = format;
60     format->next = NULL;
61 }
62
63 int match_ext(const char *filename, const char *extensions)
64 {
65     const char *ext, *p;
66     char ext1[32], *q;
67
68     if(!filename)
69         return 0;
70
71     ext = strrchr(filename, '.');
72     if (ext) {
73         ext++;
74         p = extensions;
75         for(;;) {
76             q = ext1;
77             while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
78                 *q++ = *p++;
79             *q = '\0';
80             if (!strcasecmp(ext1, ext))
81                 return 1;
82             if (*p == '\0')
83                 break;
84             p++;
85         }
86     }
87     return 0;
88 }
89
90 AVOutputFormat *guess_format(const char *short_name, const char *filename,
91                              const char *mime_type)
92 {
93     AVOutputFormat *fmt, *fmt_found;
94     int score_max, score;
95
96     /* specific test for image sequences */
97 #ifdef CONFIG_IMAGE2_MUXER
98     if (!short_name && filename &&
99         av_filename_number_test(filename) &&
100         av_guess_image2_codec(filename) != CODEC_ID_NONE) {
101         return guess_format("image2", NULL, NULL);
102     }
103 #endif
104     /* find the proper file type */
105     fmt_found = NULL;
106     score_max = 0;
107     fmt = first_oformat;
108     while (fmt != NULL) {
109         score = 0;
110         if (fmt->name && short_name && !strcmp(fmt->name, short_name))
111             score += 100;
112         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
113             score += 10;
114         if (filename && fmt->extensions &&
115             match_ext(filename, fmt->extensions)) {
116             score += 5;
117         }
118         if (score > score_max) {
119             score_max = score;
120             fmt_found = fmt;
121         }
122         fmt = fmt->next;
123     }
124     return fmt_found;
125 }
126
127 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
128                              const char *mime_type)
129 {
130     AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
131
132     if (fmt) {
133         AVOutputFormat *stream_fmt;
134         char stream_format_name[64];
135
136         snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
137         stream_fmt = guess_format(stream_format_name, NULL, NULL);
138
139         if (stream_fmt)
140             fmt = stream_fmt;
141     }
142
143     return fmt;
144 }
145
146 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
147                             const char *filename, const char *mime_type, enum CodecType type){
148     if(type == CODEC_TYPE_VIDEO){
149         enum CodecID codec_id= CODEC_ID_NONE;
150
151 #ifdef CONFIG_IMAGE2_MUXER
152         if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
153             codec_id= av_guess_image2_codec(filename);
154         }
155 #endif
156         if(codec_id == CODEC_ID_NONE)
157             codec_id= fmt->video_codec;
158         return codec_id;
159     }else if(type == CODEC_TYPE_AUDIO)
160         return fmt->audio_codec;
161     else
162         return CODEC_ID_NONE;
163 }
164
165 AVInputFormat *av_find_input_format(const char *short_name)
166 {
167     AVInputFormat *fmt;
168     for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
169         if (!strcmp(fmt->name, short_name))
170             return fmt;
171     }
172     return NULL;
173 }
174
175 /* memory handling */
176
177 void av_destruct_packet(AVPacket *pkt)
178 {
179     av_free(pkt->data);
180     pkt->data = NULL; pkt->size = 0;
181 }
182
183 void av_init_packet(AVPacket *pkt)
184 {
185     pkt->pts   = AV_NOPTS_VALUE;
186     pkt->dts   = AV_NOPTS_VALUE;
187     pkt->pos   = -1;
188     pkt->duration = 0;
189     pkt->flags = 0;
190     pkt->stream_index = 0;
191     pkt->destruct= av_destruct_packet_nofree;
192 }
193
194 int av_new_packet(AVPacket *pkt, int size)
195 {
196     uint8_t *data;
197     if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
198         return AVERROR(ENOMEM);
199     data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
200     if (!data)
201         return AVERROR(ENOMEM);
202     memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
203
204     av_init_packet(pkt);
205     pkt->data = data;
206     pkt->size = size;
207     pkt->destruct = av_destruct_packet;
208     return 0;
209 }
210
211 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
212 {
213     int ret= av_new_packet(pkt, size);
214
215     if(ret<0)
216         return ret;
217
218     pkt->pos= url_ftell(s);
219
220     ret= get_buffer(s, pkt->data, size);
221     if(ret<=0)
222         av_free_packet(pkt);
223     else
224         pkt->size= ret;
225
226     return ret;
227 }
228
229 int av_dup_packet(AVPacket *pkt)
230 {
231     if (pkt->destruct != av_destruct_packet) {
232         uint8_t *data;
233         /* we duplicate the packet and don't forget to put the padding
234            again */
235         if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
236             return AVERROR(ENOMEM);
237         data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
238         if (!data) {
239             return AVERROR(ENOMEM);
240         }
241         memcpy(data, pkt->data, pkt->size);
242         memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
243         pkt->data = data;
244         pkt->destruct = av_destruct_packet;
245     }
246     return 0;
247 }
248
249 int av_filename_number_test(const char *filename)
250 {
251     char buf[1024];
252     return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
253 }
254
255 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
256 {
257     AVInputFormat *fmt1, *fmt;
258     int score;
259
260     fmt = NULL;
261     for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
262         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
263             continue;
264         score = 0;
265         if (fmt1->read_probe) {
266             score = fmt1->read_probe(pd);
267         } else if (fmt1->extensions) {
268             if (match_ext(pd->filename, fmt1->extensions)) {
269                 score = 50;
270             }
271         }
272         if (score > *score_max) {
273             *score_max = score;
274             fmt = fmt1;
275         }
276     }
277     return fmt;
278 }
279
280 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
281     int score=0;
282     return av_probe_input_format2(pd, is_opened, &score);
283 }
284
285 /************************************************************/
286 /* input media file */
287
288 /**
289  * Open a media file from an IO stream. 'fmt' must be specified.
290  */
291 static const char* format_to_name(void* ptr)
292 {
293     AVFormatContext* fc = (AVFormatContext*) ptr;
294     if(fc->iformat) return fc->iformat->name;
295     else if(fc->oformat) return fc->oformat->name;
296     else return "NULL";
297 }
298
299 #define OFFSET(x) offsetof(AVFormatContext,x)
300 #define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
301 //these names are too long to be readable
302 #define E AV_OPT_FLAG_ENCODING_PARAM
303 #define D AV_OPT_FLAG_DECODING_PARAM
304
305 static const AVOption options[]={
306 {"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
307 {"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
308 {"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
309 {"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
310 {"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
311 {"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
312 {"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
313 {"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
314 {"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
315 {NULL},
316 };
317
318 #undef E
319 #undef D
320 #undef DEFAULT
321
322 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
323
324 static void avformat_get_context_defaults(AVFormatContext *s)
325 {
326     memset(s, 0, sizeof(AVFormatContext));
327
328     s->av_class = &av_format_context_class;
329
330     av_opt_set_defaults(s);
331 }
332
333 AVFormatContext *av_alloc_format_context(void)
334 {
335     AVFormatContext *ic;
336     ic = av_malloc(sizeof(AVFormatContext));
337     if (!ic) return ic;
338     avformat_get_context_defaults(ic);
339     ic->av_class = &av_format_context_class;
340     return ic;
341 }
342
343 int av_open_input_stream(AVFormatContext **ic_ptr,
344                          ByteIOContext *pb, const char *filename,
345                          AVInputFormat *fmt, AVFormatParameters *ap)
346 {
347     int err;
348     AVFormatContext *ic;
349     AVFormatParameters default_ap;
350
351     if(!ap){
352         ap=&default_ap;
353         memset(ap, 0, sizeof(default_ap));
354     }
355
356     if(!ap->prealloced_context)
357         ic = av_alloc_format_context();
358     else
359         ic = *ic_ptr;
360     if (!ic) {
361         err = AVERROR(ENOMEM);
362         goto fail;
363     }
364     ic->iformat = fmt;
365     if (pb)
366         ic->pb = *pb;
367     ic->duration = AV_NOPTS_VALUE;
368     ic->start_time = AV_NOPTS_VALUE;
369     av_strlcpy(ic->filename, filename, sizeof(ic->filename));
370
371     /* allocate private data */
372     if (fmt->priv_data_size > 0) {
373         ic->priv_data = av_mallocz(fmt->priv_data_size);
374         if (!ic->priv_data) {
375             err = AVERROR(ENOMEM);
376             goto fail;
377         }
378     } else {
379         ic->priv_data = NULL;
380     }
381
382     err = ic->iformat->read_header(ic, ap);
383     if (err < 0)
384         goto fail;
385
386     if (pb && !ic->data_offset)
387         ic->data_offset = url_ftell(&ic->pb);
388
389     *ic_ptr = ic;
390     return 0;
391  fail:
392     if (ic) {
393         av_freep(&ic->priv_data);
394     }
395     av_free(ic);
396     *ic_ptr = NULL;
397     return err;
398 }
399
400 /** Size of probe buffer, for guessing file type from file contents. */
401 #define PROBE_BUF_MIN 2048
402 #define PROBE_BUF_MAX (1<<20)
403
404 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
405                        AVInputFormat *fmt,
406                        int buf_size,
407                        AVFormatParameters *ap)
408 {
409     int err, must_open_file, file_opened, probe_size;
410     AVProbeData probe_data, *pd = &probe_data;
411     ByteIOContext pb1, *pb = &pb1;
412
413     file_opened = 0;
414     pd->filename = "";
415     if (filename)
416         pd->filename = filename;
417     pd->buf = NULL;
418     pd->buf_size = 0;
419
420     if (!fmt) {
421         /* guess format if no file can be opened  */
422         fmt = av_probe_input_format(pd, 0);
423     }
424
425     /* do not open file if the format does not need it. XXX: specific
426        hack needed to handle RTSP/TCP */
427     must_open_file = 1;
428     if (fmt && (fmt->flags & AVFMT_NOFILE)) {
429         must_open_file = 0;
430         pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise it is uninitialized
431     }
432
433     if (!fmt || must_open_file) {
434         /* if no file needed do not try to open one */
435         if ((err=url_fopen(pb, filename, URL_RDONLY)) < 0) {
436             goto fail;
437         }
438         file_opened = 1;
439         if (buf_size > 0) {
440             url_setbufsize(pb, buf_size);
441         }
442
443         for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
444             int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
445             /* read probe data */
446             pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
447             pd->buf_size = get_buffer(pb, pd->buf, probe_size);
448             if (url_fseek(pb, 0, SEEK_SET) < 0) {
449                 url_fclose(pb);
450                 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
451                     file_opened = 0;
452                     err = AVERROR(EIO);
453                     goto fail;
454                 }
455             }
456             /* guess file format */
457             fmt = av_probe_input_format2(pd, 1, &score);
458         }
459         av_freep(&pd->buf);
460     }
461
462     /* if still no format found, error */
463     if (!fmt) {
464         err = AVERROR_NOFMT;
465         goto fail;
466     }
467
468     /* XXX: suppress this hack for redirectors */
469 #ifdef CONFIG_REDIR_DEMUXER
470     if (fmt == &redir_demuxer) {
471         err = redir_open(ic_ptr, pb);
472         url_fclose(pb);
473         return err;
474     }
475 #endif
476
477     /* check filename in case of an image number is expected */
478     if (fmt->flags & AVFMT_NEEDNUMBER) {
479         if (!av_filename_number_test(filename)) {
480             err = AVERROR_NUMEXPECTED;
481             goto fail;
482         }
483     }
484     err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
485     if (err)
486         goto fail;
487     return 0;
488  fail:
489     av_freep(&pd->buf);
490     if (file_opened)
491         url_fclose(pb);
492     *ic_ptr = NULL;
493     return err;
494
495 }
496
497 /*******************************************************/
498
499 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
500 {
501     av_init_packet(pkt);
502     return s->iformat->read_packet(s, pkt);
503 }
504
505 /**********************************************************/
506
507 /**
508  * Get the number of samples of an audio frame. Return (-1) if error.
509  */
510 static int get_audio_frame_size(AVCodecContext *enc, int size)
511 {
512     int frame_size;
513
514     if (enc->frame_size <= 1) {
515         int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
516
517         if (bits_per_sample) {
518             if (enc->channels == 0)
519                 return -1;
520             frame_size = (size << 3) / (bits_per_sample * enc->channels);
521         } else {
522             /* used for example by ADPCM codecs */
523             if (enc->bit_rate == 0)
524                 return -1;
525             frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
526         }
527     } else {
528         frame_size = enc->frame_size;
529     }
530     return frame_size;
531 }
532
533
534 /**
535  * Return the frame duration in seconds, return 0 if not available.
536  */
537 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
538                                    AVCodecParserContext *pc, AVPacket *pkt)
539 {
540     int frame_size;
541
542     *pnum = 0;
543     *pden = 0;
544     switch(st->codec->codec_type) {
545     case CODEC_TYPE_VIDEO:
546         if(st->time_base.num*1000LL > st->time_base.den){
547             *pnum = st->time_base.num;
548             *pden = st->time_base.den;
549         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
550             *pnum = st->codec->time_base.num;
551             *pden = st->codec->time_base.den;
552             if (pc && pc->repeat_pict) {
553                 *pden *= 2;
554                 *pnum = (*pnum) * (2 + pc->repeat_pict);
555             }
556         }
557         break;
558     case CODEC_TYPE_AUDIO:
559         frame_size = get_audio_frame_size(st->codec, pkt->size);
560         if (frame_size < 0)
561             break;
562         *pnum = frame_size;
563         *pden = st->codec->sample_rate;
564         break;
565     default:
566         break;
567     }
568 }
569
570 static int is_intra_only(AVCodecContext *enc){
571     if(enc->codec_type == CODEC_TYPE_AUDIO){
572         return 1;
573     }else if(enc->codec_type == CODEC_TYPE_VIDEO){
574         switch(enc->codec_id){
575         case CODEC_ID_MJPEG:
576         case CODEC_ID_MJPEGB:
577         case CODEC_ID_LJPEG:
578         case CODEC_ID_RAWVIDEO:
579         case CODEC_ID_DVVIDEO:
580         case CODEC_ID_HUFFYUV:
581         case CODEC_ID_FFVHUFF:
582         case CODEC_ID_ASV1:
583         case CODEC_ID_ASV2:
584         case CODEC_ID_VCR1:
585             return 1;
586         default: break;
587         }
588     }
589     return 0;
590 }
591
592 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
593                                AVCodecParserContext *pc, AVPacket *pkt)
594 {
595     int num, den, presentation_delayed, delay, i;
596     int64_t offset;
597
598     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
599        /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
600         pkt->dts -= 1LL<<st->pts_wrap_bits;
601     }
602
603     if (pkt->duration == 0) {
604         compute_frame_duration(&num, &den, st, pc, pkt);
605         if (den && num) {
606             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
607         }
608     }
609
610     /* correct timestamps with byte offset if demuxers only have timestamps on packet boundaries */
611     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
612         /* this will estimate bitrate based on this frame's duration and size */
613         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
614         if(pkt->pts != AV_NOPTS_VALUE)
615             pkt->pts += offset;
616         if(pkt->dts != AV_NOPTS_VALUE)
617             pkt->dts += offset;
618     }
619
620     if(is_intra_only(st->codec))
621         pkt->flags |= PKT_FLAG_KEY;
622
623     /* do we have a video B frame ? */
624     delay= st->codec->has_b_frames;
625     presentation_delayed = 0;
626     /* XXX: need has_b_frame, but cannot get it if the codec is
627         not initialized */
628     if (delay &&
629         pc && pc->pict_type != FF_B_TYPE)
630         presentation_delayed = 1;
631     /* This may be redundant, but it should not hurt. */
632     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
633         presentation_delayed = 1;
634
635     if(st->cur_dts == AV_NOPTS_VALUE){
636         st->cur_dts = -delay * pkt->duration;
637     }
638
639 //    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);
640     /* interpolate PTS and DTS if they are not present */
641     if(delay <=1){
642         if (presentation_delayed) {
643             /* DTS = decompression time stamp */
644             /* PTS = presentation time stamp */
645             if (pkt->dts == AV_NOPTS_VALUE)
646                 pkt->dts = st->last_IP_pts;
647             if (pkt->dts == AV_NOPTS_VALUE)
648                 pkt->dts = st->cur_dts;
649
650             /* this is tricky: the dts must be incremented by the duration
651             of the frame we are displaying, i.e. the last I or P frame */
652             if (st->last_IP_duration == 0)
653                 st->last_IP_duration = pkt->duration;
654             st->cur_dts = pkt->dts + st->last_IP_duration;
655             st->last_IP_duration  = pkt->duration;
656             st->last_IP_pts= pkt->pts;
657             /* cannot compute PTS if not present (we can compute it only
658             by knowing the futur */
659         } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
660             if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
661                 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
662                 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
663                 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
664                     pkt->pts += pkt->duration;
665     //                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);
666                 }
667             }
668
669             /* presentation is not delayed : PTS and DTS are the same */
670             if(pkt->pts == AV_NOPTS_VALUE)
671                 pkt->pts = pkt->dts;
672             if(pkt->pts == AV_NOPTS_VALUE)
673                 pkt->pts = st->cur_dts;
674             pkt->dts = pkt->pts;
675             st->cur_dts = pkt->pts + pkt->duration;
676         }
677     }
678
679     if(pkt->pts != AV_NOPTS_VALUE){
680         st->pts_buffer[0]= pkt->pts;
681         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
682             st->pts_buffer[i]= (i-delay-1) * pkt->duration;
683         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
684             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
685         if(pkt->dts == AV_NOPTS_VALUE)
686             pkt->dts= st->pts_buffer[0];
687         if(pkt->dts > st->cur_dts)
688             st->cur_dts = pkt->dts;
689     }
690
691 //    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);
692
693     /* update flags */
694     if (pc) {
695         pkt->flags = 0;
696         /* key frame computation */
697             if (pc->pict_type == FF_I_TYPE)
698                 pkt->flags |= PKT_FLAG_KEY;
699     }
700 }
701
702 void av_destruct_packet_nofree(AVPacket *pkt)
703 {
704     pkt->data = NULL; pkt->size = 0;
705 }
706
707 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
708 {
709     AVStream *st;
710     int len, ret, i;
711
712     av_init_packet(pkt);
713
714     for(;;) {
715         /* select current input stream component */
716         st = s->cur_st;
717         if (st) {
718             if (!st->need_parsing || !st->parser) {
719                 /* no parsing needed: we just output the packet as is */
720                 /* raw data support */
721                 *pkt = s->cur_pkt;
722                 compute_pkt_fields(s, st, NULL, pkt);
723                 s->cur_st = NULL;
724                 break;
725             } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
726                 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
727                                       s->cur_ptr, s->cur_len,
728                                       s->cur_pkt.pts, s->cur_pkt.dts);
729                 s->cur_pkt.pts = AV_NOPTS_VALUE;
730                 s->cur_pkt.dts = AV_NOPTS_VALUE;
731                 /* increment read pointer */
732                 s->cur_ptr += len;
733                 s->cur_len -= len;
734
735                 /* return packet if any */
736                 if (pkt->size) {
737                 got_packet:
738                     pkt->pos = s->cur_pkt.pos;              // Isn't quite accurate but close.
739                     pkt->duration = 0;
740                     pkt->stream_index = st->index;
741                     pkt->pts = st->parser->pts;
742                     pkt->dts = st->parser->dts;
743                     pkt->destruct = av_destruct_packet_nofree;
744                     compute_pkt_fields(s, st, st->parser, pkt);
745
746                     if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
747                         av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
748                                            0, 0, AVINDEX_KEYFRAME);
749                     }
750
751                     break;
752                 }
753             } else {
754                 /* free packet */
755                 av_free_packet(&s->cur_pkt);
756                 s->cur_st = NULL;
757             }
758         } else {
759             /* read next packet */
760             ret = av_read_packet(s, &s->cur_pkt);
761             if (ret < 0) {
762                 if (ret == AVERROR(EAGAIN))
763                     return ret;
764                 /* return the last frames, if any */
765                 for(i = 0; i < s->nb_streams; i++) {
766                     st = s->streams[i];
767                     if (st->parser && st->need_parsing) {
768                         av_parser_parse(st->parser, st->codec,
769                                         &pkt->data, &pkt->size,
770                                         NULL, 0,
771                                         AV_NOPTS_VALUE, AV_NOPTS_VALUE);
772                         if (pkt->size)
773                             goto got_packet;
774                     }
775                 }
776                 /* no more packets: really terminates parsing */
777                 return ret;
778             }
779
780             st = s->streams[s->cur_pkt.stream_index];
781             if(st->codec->debug & FF_DEBUG_PTS)
782                 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
783                     s->cur_pkt.stream_index,
784                     s->cur_pkt.pts,
785                     s->cur_pkt.dts,
786                     s->cur_pkt.size);
787
788             s->cur_st = st;
789             s->cur_ptr = s->cur_pkt.data;
790             s->cur_len = s->cur_pkt.size;
791             if (st->need_parsing && !st->parser) {
792                 st->parser = av_parser_init(st->codec->codec_id);
793                 if (!st->parser) {
794                     /* no parser available : just output the raw packets */
795                     st->need_parsing = AVSTREAM_PARSE_NONE;
796                 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
797                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
798                 }
799                 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
800                     st->parser->last_frame_offset=
801                     st->parser->cur_offset= s->cur_pkt.pos;
802                 }
803             }
804         }
805     }
806     if(st->codec->debug & FF_DEBUG_PTS)
807         av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
808             pkt->stream_index,
809             pkt->pts,
810             pkt->dts,
811             pkt->size);
812
813     return 0;
814 }
815
816 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
817 {
818     AVPacketList *pktl;
819     int eof=0;
820     const int genpts= s->flags & AVFMT_FLAG_GENPTS;
821
822     for(;;){
823         pktl = s->packet_buffer;
824         if (pktl) {
825             AVPacket *next_pkt= &pktl->pkt;
826
827             if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
828                 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
829                     if(   pktl->pkt.stream_index == next_pkt->stream_index
830                        && next_pkt->dts < pktl->pkt.dts
831                        && pktl->pkt.pts != pktl->pkt.dts //not b frame
832                        /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
833                         next_pkt->pts= pktl->pkt.dts;
834                     }
835                     pktl= pktl->next;
836                 }
837                 pktl = s->packet_buffer;
838             }
839
840             if(   next_pkt->pts != AV_NOPTS_VALUE
841                || next_pkt->dts == AV_NOPTS_VALUE
842                || !genpts || eof){
843                 /* read packet from packet buffer, if there is data */
844                 *pkt = *next_pkt;
845                 s->packet_buffer = pktl->next;
846                 av_free(pktl);
847                 return 0;
848             }
849         }
850         if(genpts){
851             AVPacketList **plast_pktl= &s->packet_buffer;
852             int ret= av_read_frame_internal(s, pkt);
853             if(ret<0){
854                 if(pktl && ret != AVERROR(EAGAIN)){
855                     eof=1;
856                     continue;
857                 }else
858                     return ret;
859             }
860
861             /* duplicate the packet */
862             if (av_dup_packet(pkt) < 0)
863                 return AVERROR(ENOMEM);
864
865             while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
866
867             pktl = av_mallocz(sizeof(AVPacketList));
868             if (!pktl)
869                 return AVERROR(ENOMEM);
870
871             /* add the packet in the buffered packet list */
872             *plast_pktl = pktl;
873             pktl->pkt= *pkt;
874         }else{
875             assert(!s->packet_buffer);
876             return av_read_frame_internal(s, pkt);
877         }
878     }
879 }
880
881 /* XXX: suppress the packet queue */
882 static void flush_packet_queue(AVFormatContext *s)
883 {
884     AVPacketList *pktl;
885
886     for(;;) {
887         pktl = s->packet_buffer;
888         if (!pktl)
889             break;
890         s->packet_buffer = pktl->next;
891         av_free_packet(&pktl->pkt);
892         av_free(pktl);
893     }
894 }
895
896 /*******************************************************/
897 /* seek support */
898
899 int av_find_default_stream_index(AVFormatContext *s)
900 {
901     int i;
902     AVStream *st;
903
904     if (s->nb_streams <= 0)
905         return -1;
906     for(i = 0; i < s->nb_streams; i++) {
907         st = s->streams[i];
908         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
909             return i;
910         }
911     }
912     return 0;
913 }
914
915 /**
916  * Flush the frame reader.
917  */
918 static void av_read_frame_flush(AVFormatContext *s)
919 {
920     AVStream *st;
921     int i;
922
923     flush_packet_queue(s);
924
925     /* free previous packet */
926     if (s->cur_st) {
927         if (s->cur_st->parser)
928             av_free_packet(&s->cur_pkt);
929         s->cur_st = NULL;
930     }
931     /* fail safe */
932     s->cur_ptr = NULL;
933     s->cur_len = 0;
934
935     /* for each stream, reset read state */
936     for(i = 0; i < s->nb_streams; i++) {
937         st = s->streams[i];
938
939         if (st->parser) {
940             av_parser_close(st->parser);
941             st->parser = NULL;
942         }
943         st->last_IP_pts = AV_NOPTS_VALUE;
944         st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
945     }
946 }
947
948 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
949     int i;
950
951     for(i = 0; i < s->nb_streams; i++) {
952         AVStream *st = s->streams[i];
953
954         st->cur_dts = av_rescale(timestamp,
955                                  st->time_base.den * (int64_t)ref_st->time_base.num,
956                                  st->time_base.num * (int64_t)ref_st->time_base.den);
957     }
958 }
959
960 int av_add_index_entry(AVStream *st,
961                             int64_t pos, int64_t timestamp, int size, int distance, int flags)
962 {
963     AVIndexEntry *entries, *ie;
964     int index;
965
966     if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
967         return -1;
968
969     entries = av_fast_realloc(st->index_entries,
970                               &st->index_entries_allocated_size,
971                               (st->nb_index_entries + 1) *
972                               sizeof(AVIndexEntry));
973     if(!entries)
974         return -1;
975
976     st->index_entries= entries;
977
978     index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
979
980     if(index<0){
981         index= st->nb_index_entries++;
982         ie= &entries[index];
983         assert(index==0 || ie[-1].timestamp < timestamp);
984     }else{
985         ie= &entries[index];
986         if(ie->timestamp != timestamp){
987             if(ie->timestamp <= timestamp)
988                 return -1;
989             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
990             st->nb_index_entries++;
991         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
992             distance= ie->min_distance;
993     }
994
995     ie->pos = pos;
996     ie->timestamp = timestamp;
997     ie->min_distance= distance;
998     ie->size= size;
999     ie->flags = flags;
1000
1001     return index;
1002 }
1003
1004 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1005                               int flags)
1006 {
1007     AVIndexEntry *entries= st->index_entries;
1008     int nb_entries= st->nb_index_entries;
1009     int a, b, m;
1010     int64_t timestamp;
1011
1012     a = - 1;
1013     b = nb_entries;
1014
1015     while (b - a > 1) {
1016         m = (a + b) >> 1;
1017         timestamp = entries[m].timestamp;
1018         if(timestamp >= wanted_timestamp)
1019             b = m;
1020         if(timestamp <= wanted_timestamp)
1021             a = m;
1022     }
1023     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1024
1025     if(!(flags & AVSEEK_FLAG_ANY)){
1026         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1027             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1028         }
1029     }
1030
1031     if(m == nb_entries)
1032         return -1;
1033     return  m;
1034 }
1035
1036 #define DEBUG_SEEK
1037
1038 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1039     AVInputFormat *avif= s->iformat;
1040     int64_t pos_min, pos_max, pos, pos_limit;
1041     int64_t ts_min, ts_max, ts;
1042     int index;
1043     AVStream *st;
1044
1045     if (stream_index < 0)
1046         return -1;
1047
1048 #ifdef DEBUG_SEEK
1049     av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1050 #endif
1051
1052     ts_max=
1053     ts_min= AV_NOPTS_VALUE;
1054     pos_limit= -1; //gcc falsely says it may be uninitialized
1055
1056     st= s->streams[stream_index];
1057     if(st->index_entries){
1058         AVIndexEntry *e;
1059
1060         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()
1061         index= FFMAX(index, 0);
1062         e= &st->index_entries[index];
1063
1064         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1065             pos_min= e->pos;
1066             ts_min= e->timestamp;
1067 #ifdef DEBUG_SEEK
1068         av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1069                pos_min,ts_min);
1070 #endif
1071         }else{
1072             assert(index==0);
1073         }
1074
1075         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1076         assert(index < st->nb_index_entries);
1077         if(index >= 0){
1078             e= &st->index_entries[index];
1079             assert(e->timestamp >= target_ts);
1080             pos_max= e->pos;
1081             ts_max= e->timestamp;
1082             pos_limit= pos_max - e->min_distance;
1083 #ifdef DEBUG_SEEK
1084         av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1085                pos_max,pos_limit, ts_max);
1086 #endif
1087         }
1088     }
1089
1090     pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1091     if(pos<0)
1092         return -1;
1093
1094     /* do the seek */
1095     url_fseek(&s->pb, pos, SEEK_SET);
1096
1097     av_update_cur_dts(s, st, ts);
1098
1099     return 0;
1100 }
1101
1102 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 )){
1103     int64_t pos, ts;
1104     int64_t start_pos, filesize;
1105     int no_change;
1106
1107 #ifdef DEBUG_SEEK
1108     av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1109 #endif
1110
1111     if(ts_min == AV_NOPTS_VALUE){
1112         pos_min = s->data_offset;
1113         ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1114         if (ts_min == AV_NOPTS_VALUE)
1115             return -1;
1116     }
1117
1118     if(ts_max == AV_NOPTS_VALUE){
1119         int step= 1024;
1120         filesize = url_fsize(&s->pb);
1121         pos_max = filesize - 1;
1122         do{
1123             pos_max -= step;
1124             ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1125             step += step;
1126         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1127         if (ts_max == AV_NOPTS_VALUE)
1128             return -1;
1129
1130         for(;;){
1131             int64_t tmp_pos= pos_max + 1;
1132             int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1133             if(tmp_ts == AV_NOPTS_VALUE)
1134                 break;
1135             ts_max= tmp_ts;
1136             pos_max= tmp_pos;
1137             if(tmp_pos >= filesize)
1138                 break;
1139         }
1140         pos_limit= pos_max;
1141     }
1142
1143     if(ts_min > ts_max){
1144         return -1;
1145     }else if(ts_min == ts_max){
1146         pos_limit= pos_min;
1147     }
1148
1149     no_change=0;
1150     while (pos_min < pos_limit) {
1151 #ifdef DEBUG_SEEK
1152         av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1153                pos_min, pos_max,
1154                ts_min, ts_max);
1155 #endif
1156         assert(pos_limit <= pos_max);
1157
1158         if(no_change==0){
1159             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1160             // interpolate position (better than dichotomy)
1161             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1162                 + pos_min - approximate_keyframe_distance;
1163         }else if(no_change==1){
1164             // bisection, if interpolation failed to change min or max pos last time
1165             pos = (pos_min + pos_limit)>>1;
1166         }else{
1167             // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1168             pos=pos_min;
1169         }
1170         if(pos <= pos_min)
1171             pos= pos_min + 1;
1172         else if(pos > pos_limit)
1173             pos= pos_limit;
1174         start_pos= pos;
1175
1176         ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1177         if(pos == pos_max)
1178             no_change++;
1179         else
1180             no_change=0;
1181 #ifdef DEBUG_SEEK
1182 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1183 #endif
1184         if(ts == AV_NOPTS_VALUE){
1185             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1186             return -1;
1187         }
1188         assert(ts != AV_NOPTS_VALUE);
1189         if (target_ts <= ts) {
1190             pos_limit = start_pos - 1;
1191             pos_max = pos;
1192             ts_max = ts;
1193         }
1194         if (target_ts >= ts) {
1195             pos_min = pos;
1196             ts_min = ts;
1197         }
1198     }
1199
1200     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1201     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1202 #ifdef DEBUG_SEEK
1203     pos_min = pos;
1204     ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1205     pos_min++;
1206     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1207     av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1208            pos, ts_min, target_ts, ts_max);
1209 #endif
1210     *ts_ret= ts;
1211     return pos;
1212 }
1213
1214 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1215     int64_t pos_min, pos_max;
1216 #if 0
1217     AVStream *st;
1218
1219     if (stream_index < 0)
1220         return -1;
1221
1222     st= s->streams[stream_index];
1223 #endif
1224
1225     pos_min = s->data_offset;
1226     pos_max = url_fsize(&s->pb) - 1;
1227
1228     if     (pos < pos_min) pos= pos_min;
1229     else if(pos > pos_max) pos= pos_max;
1230
1231     url_fseek(&s->pb, pos, SEEK_SET);
1232
1233 #if 0
1234     av_update_cur_dts(s, st, ts);
1235 #endif
1236     return 0;
1237 }
1238
1239 static int av_seek_frame_generic(AVFormatContext *s,
1240                                  int stream_index, int64_t timestamp, int flags)
1241 {
1242     int index;
1243     AVStream *st;
1244     AVIndexEntry *ie;
1245
1246     st = s->streams[stream_index];
1247
1248     index = av_index_search_timestamp(st, timestamp, flags);
1249
1250     if(index < 0 || index==st->nb_index_entries-1){
1251         int i;
1252         AVPacket pkt;
1253
1254         if(st->index_entries && st->nb_index_entries){
1255             ie= &st->index_entries[st->nb_index_entries-1];
1256             url_fseek(&s->pb, ie->pos, SEEK_SET);
1257             av_update_cur_dts(s, st, ie->timestamp);
1258         }else
1259             url_fseek(&s->pb, 0, SEEK_SET);
1260
1261         for(i=0;; i++) {
1262             int ret = av_read_frame(s, &pkt);
1263             if(ret<0)
1264                 break;
1265             av_free_packet(&pkt);
1266             if(stream_index == pkt.stream_index){
1267                 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1268                     break;
1269             }
1270         }
1271         index = av_index_search_timestamp(st, timestamp, flags);
1272     }
1273     if (index < 0)
1274         return -1;
1275
1276     av_read_frame_flush(s);
1277     if (s->iformat->read_seek){
1278         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1279             return 0;
1280     }
1281     ie = &st->index_entries[index];
1282     url_fseek(&s->pb, ie->pos, SEEK_SET);
1283
1284     av_update_cur_dts(s, st, ie->timestamp);
1285
1286     return 0;
1287 }
1288
1289 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1290 {
1291     int ret;
1292     AVStream *st;
1293
1294     av_read_frame_flush(s);
1295
1296     if(flags & AVSEEK_FLAG_BYTE)
1297         return av_seek_frame_byte(s, stream_index, timestamp, flags);
1298
1299     if(stream_index < 0){
1300         stream_index= av_find_default_stream_index(s);
1301         if(stream_index < 0)
1302             return -1;
1303
1304         st= s->streams[stream_index];
1305        /* timestamp for default must be expressed in AV_TIME_BASE units */
1306         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1307     }
1308     st= s->streams[stream_index];
1309
1310     /* first, we try the format specific seek */
1311     if (s->iformat->read_seek)
1312         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1313     else
1314         ret = -1;
1315     if (ret >= 0) {
1316         return 0;
1317     }
1318
1319     if(s->iformat->read_timestamp)
1320         return av_seek_frame_binary(s, stream_index, timestamp, flags);
1321     else
1322         return av_seek_frame_generic(s, stream_index, timestamp, flags);
1323 }
1324
1325 /*******************************************************/
1326
1327 /**
1328  * Returns TRUE if the stream has accurate timings in any stream.
1329  *
1330  * @return TRUE if the stream has accurate timings for at least one component.
1331  */
1332 static int av_has_timings(AVFormatContext *ic)
1333 {
1334     int i;
1335     AVStream *st;
1336
1337     for(i = 0;i < ic->nb_streams; i++) {
1338         st = ic->streams[i];
1339         if (st->start_time != AV_NOPTS_VALUE &&
1340             st->duration != AV_NOPTS_VALUE)
1341             return 1;
1342     }
1343     return 0;
1344 }
1345
1346 /**
1347  * Estimate the stream timings from the one of each components.
1348  *
1349  * Also computes the global bitrate if possible.
1350  */
1351 static void av_update_stream_timings(AVFormatContext *ic)
1352 {
1353     int64_t start_time, start_time1, end_time, end_time1;
1354     int i;
1355     AVStream *st;
1356
1357     start_time = INT64_MAX;
1358     end_time = INT64_MIN;
1359     for(i = 0;i < ic->nb_streams; i++) {
1360         st = ic->streams[i];
1361         if (st->start_time != AV_NOPTS_VALUE) {
1362             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1363             if (start_time1 < start_time)
1364                 start_time = start_time1;
1365             if (st->duration != AV_NOPTS_VALUE) {
1366                 end_time1 = start_time1
1367                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1368                 if (end_time1 > end_time)
1369                     end_time = end_time1;
1370             }
1371         }
1372     }
1373     if (start_time != INT64_MAX) {
1374         ic->start_time = start_time;
1375         if (end_time != INT64_MIN) {
1376             ic->duration = end_time - start_time;
1377             if (ic->file_size > 0) {
1378                 /* compute the bit rate */
1379                 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1380                     (double)ic->duration;
1381             }
1382         }
1383     }
1384
1385 }
1386
1387 static void fill_all_stream_timings(AVFormatContext *ic)
1388 {
1389     int i;
1390     AVStream *st;
1391
1392     av_update_stream_timings(ic);
1393     for(i = 0;i < ic->nb_streams; i++) {
1394         st = ic->streams[i];
1395         if (st->start_time == AV_NOPTS_VALUE) {
1396             if(ic->start_time != AV_NOPTS_VALUE)
1397                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1398             if(ic->duration != AV_NOPTS_VALUE)
1399                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1400         }
1401     }
1402 }
1403
1404 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1405 {
1406     int64_t filesize, duration;
1407     int bit_rate, i;
1408     AVStream *st;
1409
1410     /* if bit_rate is already set, we believe it */
1411     if (ic->bit_rate == 0) {
1412         bit_rate = 0;
1413         for(i=0;i<ic->nb_streams;i++) {
1414             st = ic->streams[i];
1415             bit_rate += st->codec->bit_rate;
1416         }
1417         ic->bit_rate = bit_rate;
1418     }
1419
1420     /* if duration is already set, we believe it */
1421     if (ic->duration == AV_NOPTS_VALUE &&
1422         ic->bit_rate != 0 &&
1423         ic->file_size != 0)  {
1424         filesize = ic->file_size;
1425         if (filesize > 0) {
1426             for(i = 0; i < ic->nb_streams; i++) {
1427                 st = ic->streams[i];
1428                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1429                 if (st->start_time == AV_NOPTS_VALUE ||
1430                     st->duration == AV_NOPTS_VALUE) {
1431                     st->start_time = 0;
1432                     st->duration = duration;
1433                 }
1434             }
1435         }
1436     }
1437 }
1438
1439 #define DURATION_MAX_READ_SIZE 250000
1440
1441 /* only usable for MPEG-PS streams */
1442 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1443 {
1444     AVPacket pkt1, *pkt = &pkt1;
1445     AVStream *st;
1446     int read_size, i, ret;
1447     int64_t end_time;
1448     int64_t filesize, offset, duration;
1449
1450     /* free previous packet */
1451     if (ic->cur_st && ic->cur_st->parser)
1452         av_free_packet(&ic->cur_pkt);
1453     ic->cur_st = NULL;
1454
1455     /* flush packet queue */
1456     flush_packet_queue(ic);
1457
1458     for(i=0;i<ic->nb_streams;i++) {
1459         st = ic->streams[i];
1460         if (st->parser) {
1461             av_parser_close(st->parser);
1462             st->parser= NULL;
1463         }
1464     }
1465
1466     /* we read the first packets to get the first PTS (not fully
1467        accurate, but it is enough now) */
1468     url_fseek(&ic->pb, 0, SEEK_SET);
1469     read_size = 0;
1470     for(;;) {
1471         if (read_size >= DURATION_MAX_READ_SIZE)
1472             break;
1473         /* if all info is available, we can stop */
1474         for(i = 0;i < ic->nb_streams; i++) {
1475             st = ic->streams[i];
1476             if (st->start_time == AV_NOPTS_VALUE)
1477                 break;
1478         }
1479         if (i == ic->nb_streams)
1480             break;
1481
1482         ret = av_read_packet(ic, pkt);
1483         if (ret != 0)
1484             break;
1485         read_size += pkt->size;
1486         st = ic->streams[pkt->stream_index];
1487         if (pkt->pts != AV_NOPTS_VALUE) {
1488             if (st->start_time == AV_NOPTS_VALUE)
1489                 st->start_time = pkt->pts;
1490         }
1491         av_free_packet(pkt);
1492     }
1493
1494     /* estimate the end time (duration) */
1495     /* XXX: may need to support wrapping */
1496     filesize = ic->file_size;
1497     offset = filesize - DURATION_MAX_READ_SIZE;
1498     if (offset < 0)
1499         offset = 0;
1500
1501     url_fseek(&ic->pb, offset, SEEK_SET);
1502     read_size = 0;
1503     for(;;) {
1504         if (read_size >= DURATION_MAX_READ_SIZE)
1505             break;
1506         /* if all info is available, we can stop */
1507         for(i = 0;i < ic->nb_streams; i++) {
1508             st = ic->streams[i];
1509             if (st->duration == AV_NOPTS_VALUE)
1510                 break;
1511         }
1512         if (i == ic->nb_streams)
1513             break;
1514
1515         ret = av_read_packet(ic, pkt);
1516         if (ret != 0)
1517             break;
1518         read_size += pkt->size;
1519         st = ic->streams[pkt->stream_index];
1520         if (pkt->pts != AV_NOPTS_VALUE) {
1521             end_time = pkt->pts;
1522             duration = end_time - st->start_time;
1523             if (duration > 0) {
1524                 if (st->duration == AV_NOPTS_VALUE ||
1525                     st->duration < duration)
1526                     st->duration = duration;
1527             }
1528         }
1529         av_free_packet(pkt);
1530     }
1531
1532     fill_all_stream_timings(ic);
1533
1534     url_fseek(&ic->pb, old_offset, SEEK_SET);
1535 }
1536
1537 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1538 {
1539     int64_t file_size;
1540
1541     /* get the file size, if possible */
1542     if (ic->iformat->flags & AVFMT_NOFILE) {
1543         file_size = 0;
1544     } else {
1545         file_size = url_fsize(&ic->pb);
1546         if (file_size < 0)
1547             file_size = 0;
1548     }
1549     ic->file_size = file_size;
1550
1551     if ((!strcmp(ic->iformat->name, "mpeg") ||
1552          !strcmp(ic->iformat->name, "mpegts")) &&
1553         file_size && !ic->pb.is_streamed) {
1554         /* get accurate estimate from the PTSes */
1555         av_estimate_timings_from_pts(ic, old_offset);
1556     } else if (av_has_timings(ic)) {
1557         /* at least one components has timings - we use them for all
1558            the components */
1559         fill_all_stream_timings(ic);
1560     } else {
1561         /* less precise: use bit rate info */
1562         av_estimate_timings_from_bit_rate(ic);
1563     }
1564     av_update_stream_timings(ic);
1565
1566 #if 0
1567     {
1568         int i;
1569         AVStream *st;
1570         for(i = 0;i < ic->nb_streams; i++) {
1571             st = ic->streams[i];
1572         printf("%d: start_time: %0.3f duration: %0.3f\n",
1573                i, (double)st->start_time / AV_TIME_BASE,
1574                (double)st->duration / AV_TIME_BASE);
1575         }
1576         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1577                (double)ic->start_time / AV_TIME_BASE,
1578                (double)ic->duration / AV_TIME_BASE,
1579                ic->bit_rate / 1000);
1580     }
1581 #endif
1582 }
1583
1584 static int has_codec_parameters(AVCodecContext *enc)
1585 {
1586     int val;
1587     switch(enc->codec_type) {
1588     case CODEC_TYPE_AUDIO:
1589         val = enc->sample_rate;
1590         break;
1591     case CODEC_TYPE_VIDEO:
1592         val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1593         break;
1594     default:
1595         val = 1;
1596         break;
1597     }
1598     return (val != 0);
1599 }
1600
1601 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1602 {
1603     int16_t *samples;
1604     AVCodec *codec;
1605     int got_picture, data_size, ret=0;
1606     AVFrame picture;
1607
1608   if(!st->codec->codec){
1609     codec = avcodec_find_decoder(st->codec->codec_id);
1610     if (!codec)
1611         return -1;
1612     ret = avcodec_open(st->codec, codec);
1613     if (ret < 0)
1614         return ret;
1615   }
1616
1617   if(!has_codec_parameters(st->codec)){
1618     switch(st->codec->codec_type) {
1619     case CODEC_TYPE_VIDEO:
1620         ret = avcodec_decode_video(st->codec, &picture,
1621                                    &got_picture, (uint8_t *)data, size);
1622         break;
1623     case CODEC_TYPE_AUDIO:
1624         data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1625         samples = av_malloc(data_size);
1626         if (!samples)
1627             goto fail;
1628         ret = avcodec_decode_audio2(st->codec, samples,
1629                                     &data_size, (uint8_t *)data, size);
1630         av_free(samples);
1631         break;
1632     default:
1633         break;
1634     }
1635   }
1636  fail:
1637     return ret;
1638 }
1639
1640 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1641 {
1642     AVInputFormat *fmt;
1643     fmt = av_probe_input_format2(pd, 1, &score);
1644
1645     if (fmt) {
1646         if (strncmp(fmt->name, "mp3", 3) == 0)
1647             st->codec->codec_id = CODEC_ID_MP3;
1648         else if (strncmp(fmt->name, "ac3", 3) == 0)
1649             st->codec->codec_id = CODEC_ID_AC3;
1650     }
1651     return !!fmt;
1652 }
1653
1654 unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1655 {
1656     while (tags->id != CODEC_ID_NONE) {
1657         if (tags->id == id)
1658             return tags->tag;
1659         tags++;
1660     }
1661     return 0;
1662 }
1663
1664 enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1665 {
1666     int i;
1667     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1668         if(tag == tags[i].tag)
1669             return tags[i].id;
1670     }
1671     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1672         if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1673            && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1674            && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1675            && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1676             return tags[i].id;
1677     }
1678     return CODEC_ID_NONE;
1679 }
1680
1681 unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1682 {
1683     int i;
1684     for(i=0; tags && tags[i]; i++){
1685         int tag= codec_get_tag(tags[i], id);
1686         if(tag) return tag;
1687     }
1688     return 0;
1689 }
1690
1691 enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1692 {
1693     int i;
1694     for(i=0; tags && tags[i]; i++){
1695         enum CodecID id= codec_get_id(tags[i], tag);
1696         if(id!=CODEC_ID_NONE) return id;
1697     }
1698     return CODEC_ID_NONE;
1699 }
1700
1701 /* absolute maximum size we read until we abort */
1702 #define MAX_READ_SIZE        5000000
1703
1704 #define MAX_STD_TIMEBASES (60*12+5)
1705 static int get_std_framerate(int i){
1706     if(i<60*12) return i*1001;
1707     else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1708 }
1709
1710 int av_find_stream_info(AVFormatContext *ic)
1711 {
1712     int i, count, ret, read_size, j;
1713     AVStream *st;
1714     AVPacket pkt1, *pkt;
1715     AVPacketList *pktl=NULL, **ppktl;
1716     int64_t last_dts[MAX_STREAMS];
1717     int duration_count[MAX_STREAMS]={0};
1718     double (*duration_error)[MAX_STD_TIMEBASES];
1719     offset_t old_offset = url_ftell(&ic->pb);
1720     int64_t codec_info_duration[MAX_STREAMS]={0};
1721     int codec_info_nb_frames[MAX_STREAMS]={0};
1722     AVProbeData probe_data[MAX_STREAMS];
1723     int codec_identified[MAX_STREAMS]={0};
1724
1725     duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1726     if (!duration_error) return AVERROR(ENOMEM);
1727
1728     for(i=0;i<ic->nb_streams;i++) {
1729         st = ic->streams[i];
1730         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1731 /*            if(!st->time_base.num)
1732                 st->time_base= */
1733             if(!st->codec->time_base.num)
1734                 st->codec->time_base= st->time_base;
1735         }
1736         //only for the split stuff
1737         if (!st->parser) {
1738             st->parser = av_parser_init(st->codec->codec_id);
1739             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1740                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1741             }
1742         }
1743     }
1744
1745     for(i=0;i<MAX_STREAMS;i++){
1746         last_dts[i]= AV_NOPTS_VALUE;
1747     }
1748
1749     memset(probe_data, 0, sizeof(probe_data));
1750     count = 0;
1751     read_size = 0;
1752     ppktl = &ic->packet_buffer;
1753     for(;;) {
1754         /* check if one codec still needs to be handled */
1755         for(i=0;i<ic->nb_streams;i++) {
1756             st = ic->streams[i];
1757             if (!has_codec_parameters(st->codec))
1758                 break;
1759             /* variable fps and no guess at the real fps */
1760             if(   (st->codec->time_base.den >= 101LL*st->codec->time_base.num || st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
1761                && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1762                 break;
1763             if(st->parser && st->parser->parser->split && !st->codec->extradata)
1764                 break;
1765             if (st->codec->codec_type == CODEC_TYPE_AUDIO &&
1766                 st->codec->codec_id == CODEC_ID_NONE)
1767                 break;
1768         }
1769         if (i == ic->nb_streams) {
1770             /* NOTE: if the format has no header, then we need to read
1771                some packets to get most of the streams, so we cannot
1772                stop here */
1773             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1774                 /* if we found the info for all the codecs, we can stop */
1775                 ret = count;
1776                 break;
1777             }
1778         }
1779         /* we did not get all the codec info, but we read too much data */
1780         if (read_size >= MAX_READ_SIZE) {
1781             ret = count;
1782             break;
1783         }
1784
1785         /* NOTE: a new stream can be added there if no header in file
1786            (AVFMTCTX_NOHEADER) */
1787         ret = av_read_frame_internal(ic, &pkt1);
1788         if (ret < 0) {
1789             /* EOF or error */
1790             ret = -1; /* we could not have all the codec parameters before EOF */
1791             for(i=0;i<ic->nb_streams;i++) {
1792                 st = ic->streams[i];
1793                 if (!has_codec_parameters(st->codec)){
1794                     char buf[256];
1795                     avcodec_string(buf, sizeof(buf), st->codec, 0);
1796                     av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1797                 } else {
1798                     ret = 0;
1799                 }
1800             }
1801             break;
1802         }
1803
1804         pktl = av_mallocz(sizeof(AVPacketList));
1805         if (!pktl) {
1806             ret = AVERROR(ENOMEM);
1807             break;
1808         }
1809
1810         /* add the packet in the buffered packet list */
1811         *ppktl = pktl;
1812         ppktl = &pktl->next;
1813
1814         pkt = &pktl->pkt;
1815         *pkt = pkt1;
1816
1817         /* duplicate the packet */
1818         if (av_dup_packet(pkt) < 0) {
1819             ret = AVERROR(ENOMEM);
1820             break;
1821         }
1822
1823         read_size += pkt->size;
1824
1825         st = ic->streams[pkt->stream_index];
1826         if(codec_info_nb_frames[st->index]>1)
1827             codec_info_duration[st->index] += pkt->duration;
1828         if (pkt->duration != 0)
1829             codec_info_nb_frames[st->index]++;
1830
1831         {
1832             int index= pkt->stream_index;
1833             int64_t last= last_dts[index];
1834             int64_t duration= pkt->dts - last;
1835
1836             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1837                 double dur= duration * av_q2d(st->time_base);
1838
1839 //                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1840 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1841                 if(duration_count[index] < 2)
1842                     memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1843                 for(i=1; i<MAX_STD_TIMEBASES; i++){
1844                     int framerate= get_std_framerate(i);
1845                     int ticks= lrintf(dur*framerate/(1001*12));
1846                     double error= dur - ticks*1001*12/(double)framerate;
1847                     duration_error[index][i] += error*error;
1848                 }
1849                 duration_count[index]++;
1850             }
1851             if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1852                 last_dts[pkt->stream_index]= pkt->dts;
1853
1854             if (st->codec->codec_id == CODEC_ID_NONE) {
1855                 AVProbeData *pd = &(probe_data[st->index]);
1856                 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size);
1857                 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1858                 pd->buf_size += pkt->size;
1859             }
1860         }
1861         if(st->parser && st->parser->parser->split && !st->codec->extradata){
1862             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1863             if(i){
1864                 st->codec->extradata_size= i;
1865                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1866                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1867                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1868             }
1869         }
1870
1871         /* if still no information, we try to open the codec and to
1872            decompress the frame. We try to avoid that in most cases as
1873            it takes longer and uses more memory. For MPEG4, we need to
1874            decompress for Quicktime. */
1875         if (!has_codec_parameters(st->codec) /*&&
1876             (st->codec->codec_id == CODEC_ID_FLV1 ||
1877              st->codec->codec_id == CODEC_ID_H264 ||
1878              st->codec->codec_id == CODEC_ID_H263 ||
1879              st->codec->codec_id == CODEC_ID_H261 ||
1880              st->codec->codec_id == CODEC_ID_VORBIS ||
1881              st->codec->codec_id == CODEC_ID_MJPEG ||
1882              st->codec->codec_id == CODEC_ID_PNG ||
1883              st->codec->codec_id == CODEC_ID_PAM ||
1884              st->codec->codec_id == CODEC_ID_PGM ||
1885              st->codec->codec_id == CODEC_ID_PGMYUV ||
1886              st->codec->codec_id == CODEC_ID_PBM ||
1887              st->codec->codec_id == CODEC_ID_PPM ||
1888              st->codec->codec_id == CODEC_ID_SHORTEN ||
1889              (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1890             try_decode_frame(st, pkt->data, pkt->size);
1891
1892         if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1893             break;
1894         }
1895         count++;
1896     }
1897
1898     // close codecs which where opened in try_decode_frame()
1899     for(i=0;i<ic->nb_streams;i++) {
1900         st = ic->streams[i];
1901         if(st->codec->codec)
1902             avcodec_close(st->codec);
1903     }
1904     for(i=0;i<ic->nb_streams;i++) {
1905         st = ic->streams[i];
1906         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1907             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1908                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1909
1910             if(duration_count[i]
1911                && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1912                //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1913                st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1914                 double best_error= 2*av_q2d(st->time_base);
1915                 best_error= best_error*best_error*duration_count[i]*1000*12*30;
1916
1917                 for(j=1; j<MAX_STD_TIMEBASES; j++){
1918                     double error= duration_error[i][j] * get_std_framerate(j);
1919 //                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1920 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1921                     if(error < best_error){
1922                         best_error= error;
1923                         av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1924                     }
1925                 }
1926             }
1927
1928             if (!st->r_frame_rate.num){
1929                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
1930                     <= st->codec->time_base.num * (int64_t)st->time_base.den){
1931                     st->r_frame_rate.num = st->codec->time_base.den;
1932                     st->r_frame_rate.den = st->codec->time_base.num;
1933                 }else{
1934                     st->r_frame_rate.num = st->time_base.den;
1935                     st->r_frame_rate.den = st->time_base.num;
1936                 }
1937             }
1938         }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1939             if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
1940                 codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
1941                 if (codec_identified[st->index]) {
1942                     st->need_parsing = AVSTREAM_PARSE_FULL;
1943                 }
1944             }
1945             if(!st->codec->bits_per_sample)
1946                 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1947         }
1948     }
1949
1950     av_estimate_timings(ic, old_offset);
1951
1952     for(i=0;i<ic->nb_streams;i++) {
1953         st = ic->streams[i];
1954         if (codec_identified[st->index]) {
1955             av_read_frame_flush(ic);
1956             av_seek_frame(ic, st->index, 0.0, 0);
1957             url_fseek(&ic->pb, ic->data_offset, SEEK_SET);
1958         }
1959     }
1960
1961 #if 0
1962     /* correct DTS for b frame streams with no timestamps */
1963     for(i=0;i<ic->nb_streams;i++) {
1964         st = ic->streams[i];
1965         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1966             if(b-frames){
1967                 ppktl = &ic->packet_buffer;
1968                 while(ppkt1){
1969                     if(ppkt1->stream_index != i)
1970                         continue;
1971                     if(ppkt1->pkt->dts < 0)
1972                         break;
1973                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1974                         break;
1975                     ppkt1->pkt->dts -= delta;
1976                     ppkt1= ppkt1->next;
1977                 }
1978                 if(ppkt1)
1979                     continue;
1980                 st->cur_dts -= delta;
1981             }
1982         }
1983     }
1984 #endif
1985
1986     av_free(duration_error);
1987     for(i=0;i<MAX_STREAMS;i++){
1988         av_freep(&(probe_data[i].buf));
1989     }
1990
1991     return ret;
1992 }
1993
1994 /*******************************************************/
1995
1996 int av_read_play(AVFormatContext *s)
1997 {
1998     if (!s->iformat->read_play)
1999         return AVERROR(ENOSYS);
2000     return s->iformat->read_play(s);
2001 }
2002
2003 int av_read_pause(AVFormatContext *s)
2004 {
2005     if (!s->iformat->read_pause)
2006         return AVERROR(ENOSYS);
2007     return s->iformat->read_pause(s);
2008 }
2009
2010 void av_close_input_file(AVFormatContext *s)
2011 {
2012     int i, must_open_file;
2013     AVStream *st;
2014
2015     /* free previous packet */
2016     if (s->cur_st && s->cur_st->parser)
2017         av_free_packet(&s->cur_pkt);
2018
2019     if (s->iformat->read_close)
2020         s->iformat->read_close(s);
2021     for(i=0;i<s->nb_streams;i++) {
2022         /* free all data in a stream component */
2023         st = s->streams[i];
2024         if (st->parser) {
2025             av_parser_close(st->parser);
2026         }
2027         av_free(st->index_entries);
2028         av_free(st->codec->extradata);
2029         av_free(st->codec);
2030         av_free(st);
2031     }
2032     flush_packet_queue(s);
2033     must_open_file = 1;
2034     if (s->iformat->flags & AVFMT_NOFILE) {
2035         must_open_file = 0;
2036     }
2037     if (must_open_file) {
2038         url_fclose(&s->pb);
2039     }
2040     av_freep(&s->priv_data);
2041     av_free(s);
2042 }
2043
2044 AVStream *av_new_stream(AVFormatContext *s, int id)
2045 {
2046     AVStream *st;
2047     int i;
2048
2049     if (s->nb_streams >= MAX_STREAMS)
2050         return NULL;
2051
2052     st = av_mallocz(sizeof(AVStream));
2053     if (!st)
2054         return NULL;
2055
2056     st->codec= avcodec_alloc_context();
2057     if (s->iformat) {
2058         /* no default bitrate if decoding */
2059         st->codec->bit_rate = 0;
2060     }
2061     st->index = s->nb_streams;
2062     st->id = id;
2063     st->start_time = AV_NOPTS_VALUE;
2064     st->duration = AV_NOPTS_VALUE;
2065     st->cur_dts = AV_NOPTS_VALUE;
2066
2067     /* default pts settings is MPEG like */
2068     av_set_pts_info(st, 33, 1, 90000);
2069     st->last_IP_pts = AV_NOPTS_VALUE;
2070     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2071         st->pts_buffer[i]= AV_NOPTS_VALUE;
2072
2073     s->streams[s->nb_streams++] = st;
2074     return st;
2075 }
2076
2077 /************************************************************/
2078 /* output media file */
2079
2080 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2081 {
2082     int ret;
2083
2084     if (s->oformat->priv_data_size > 0) {
2085         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2086         if (!s->priv_data)
2087             return AVERROR(ENOMEM);
2088     } else
2089         s->priv_data = NULL;
2090
2091     if (s->oformat->set_parameters) {
2092         ret = s->oformat->set_parameters(s, ap);
2093         if (ret < 0)
2094             return ret;
2095     }
2096     return 0;
2097 }
2098
2099 int av_write_header(AVFormatContext *s)
2100 {
2101     int ret, i;
2102     AVStream *st;
2103
2104     // some sanity checks
2105     for(i=0;i<s->nb_streams;i++) {
2106         st = s->streams[i];
2107
2108         switch (st->codec->codec_type) {
2109         case CODEC_TYPE_AUDIO:
2110             if(st->codec->sample_rate<=0){
2111                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2112                 return -1;
2113             }
2114             break;
2115         case CODEC_TYPE_VIDEO:
2116             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2117                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2118                 return -1;
2119             }
2120             if(st->codec->width<=0 || st->codec->height<=0){
2121                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2122                 return -1;
2123             }
2124             break;
2125         }
2126
2127         if(s->oformat->codec_tag){
2128             if(st->codec->codec_tag){
2129                 //FIXME
2130                 //check that tag + id is in the table
2131                 //if neither is in the table -> ok
2132                 //if tag is in the table with another id -> FAIL
2133                 //if id is in the table with another tag -> FAIL unless strict < ?
2134             }else
2135                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2136         }
2137     }
2138
2139     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2140         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2141         if (!s->priv_data)
2142             return AVERROR(ENOMEM);
2143     }
2144
2145     if(s->oformat->write_header){
2146         ret = s->oformat->write_header(s);
2147         if (ret < 0)
2148             return ret;
2149     }
2150
2151     /* init PTS generation */
2152     for(i=0;i<s->nb_streams;i++) {
2153         int64_t den = AV_NOPTS_VALUE;
2154         st = s->streams[i];
2155
2156         switch (st->codec->codec_type) {
2157         case CODEC_TYPE_AUDIO:
2158             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2159             break;
2160         case CODEC_TYPE_VIDEO:
2161             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2162             break;
2163         default:
2164             break;
2165         }
2166         if (den != AV_NOPTS_VALUE) {
2167             if (den <= 0)
2168                 return AVERROR_INVALIDDATA;
2169             av_frac_init(&st->pts, 0, 0, den);
2170         }
2171     }
2172     return 0;
2173 }
2174
2175 //FIXME merge with compute_pkt_fields
2176 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2177     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2178     int num, den, frame_size, i;
2179
2180 //    av_log(st->codec, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2181
2182 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2183         return -1;*/
2184
2185     /* duration field */
2186     if (pkt->duration == 0) {
2187         compute_frame_duration(&num, &den, st, NULL, pkt);
2188         if (den && num) {
2189             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2190         }
2191     }
2192
2193     //XXX/FIXME this is a temporary hack until all encoders output pts
2194     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2195         pkt->dts=
2196 //        pkt->pts= st->cur_dts;
2197         pkt->pts= st->pts.val;
2198     }
2199
2200     //calculate dts from pts
2201     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2202         st->pts_buffer[0]= pkt->pts;
2203         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2204             st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2205         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2206             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2207
2208         pkt->dts= st->pts_buffer[0];
2209     }
2210
2211     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2212         av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2213         return -1;
2214     }
2215     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2216         av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2217         return -1;
2218     }
2219
2220 //    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2221     st->cur_dts= pkt->dts;
2222     st->pts.val= pkt->dts;
2223
2224     /* update pts */
2225     switch (st->codec->codec_type) {
2226     case CODEC_TYPE_AUDIO:
2227         frame_size = get_audio_frame_size(st->codec, pkt->size);
2228
2229         /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2230            but it would be better if we had the real timestamps from the encoder */
2231         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2232             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2233         }
2234         break;
2235     case CODEC_TYPE_VIDEO:
2236         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2237         break;
2238     default:
2239         break;
2240     }
2241     return 0;
2242 }
2243
2244 static void truncate_ts(AVStream *st, AVPacket *pkt){
2245     int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2246
2247 //    if(pkt->dts < 0)
2248 //        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2249
2250     if (pkt->pts != AV_NOPTS_VALUE)
2251         pkt->pts &= pts_mask;
2252     if (pkt->dts != AV_NOPTS_VALUE)
2253         pkt->dts &= pts_mask;
2254 }
2255
2256 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2257 {
2258     int ret;
2259
2260     ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2261     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2262         return ret;
2263
2264     truncate_ts(s->streams[pkt->stream_index], pkt);
2265
2266     ret= s->oformat->write_packet(s, pkt);
2267     if(!ret)
2268         ret= url_ferror(&s->pb);
2269     return ret;
2270 }
2271
2272 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2273     AVPacketList *pktl, **next_point, *this_pktl;
2274     int stream_count=0;
2275     int streams[MAX_STREAMS];
2276
2277     if(pkt){
2278         AVStream *st= s->streams[ pkt->stream_index];
2279
2280 //        assert(pkt->destruct != av_destruct_packet); //FIXME
2281
2282         this_pktl = av_mallocz(sizeof(AVPacketList));
2283         this_pktl->pkt= *pkt;
2284         if(pkt->destruct == av_destruct_packet)
2285             pkt->destruct= NULL; // non shared -> must keep original from being freed
2286         else
2287             av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2288
2289         next_point = &s->packet_buffer;
2290         while(*next_point){
2291             AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2292             int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2293             int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2294             if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2295                 break;
2296             next_point= &(*next_point)->next;
2297         }
2298         this_pktl->next= *next_point;
2299         *next_point= this_pktl;
2300     }
2301
2302     memset(streams, 0, sizeof(streams));
2303     pktl= s->packet_buffer;
2304     while(pktl){
2305 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2306         if(streams[ pktl->pkt.stream_index ] == 0)
2307             stream_count++;
2308         streams[ pktl->pkt.stream_index ]++;
2309         pktl= pktl->next;
2310     }
2311
2312     if(s->nb_streams == stream_count || (flush && stream_count)){
2313         pktl= s->packet_buffer;
2314         *out= pktl->pkt;
2315
2316         s->packet_buffer= pktl->next;
2317         av_freep(&pktl);
2318         return 1;
2319     }else{
2320         av_init_packet(out);
2321         return 0;
2322     }
2323 }
2324
2325 /**
2326  * Interleaves a AVPacket correctly so it can be muxed.
2327  * @param out the interleaved packet will be output here
2328  * @param in the input packet
2329  * @param flush 1 if no further packets are available as input and all
2330  *              remaining packets should be output
2331  * @return 1 if a packet was output, 0 if no packet could be output,
2332  *         < 0 if an error occured
2333  */
2334 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2335     if(s->oformat->interleave_packet)
2336         return s->oformat->interleave_packet(s, out, in, flush);
2337     else
2338         return av_interleave_packet_per_dts(s, out, in, flush);
2339 }
2340
2341 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2342     AVStream *st= s->streams[ pkt->stream_index];
2343
2344     //FIXME/XXX/HACK drop zero sized packets
2345     if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2346         return 0;
2347
2348 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2349     if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2350         return -1;
2351
2352     if(pkt->dts == AV_NOPTS_VALUE)
2353         return -1;
2354
2355     for(;;){
2356         AVPacket opkt;
2357         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2358         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2359             return ret;
2360
2361         truncate_ts(s->streams[opkt.stream_index], &opkt);
2362         ret= s->oformat->write_packet(s, &opkt);
2363
2364         av_free_packet(&opkt);
2365         pkt= NULL;
2366
2367         if(ret<0)
2368             return ret;
2369         if(url_ferror(&s->pb))
2370             return url_ferror(&s->pb);
2371     }
2372 }
2373
2374 int av_write_trailer(AVFormatContext *s)
2375 {
2376     int ret, i;
2377
2378     for(;;){
2379         AVPacket pkt;
2380         ret= av_interleave_packet(s, &pkt, NULL, 1);
2381         if(ret<0) //FIXME cleanup needed for ret<0 ?
2382             goto fail;
2383         if(!ret)
2384             break;
2385
2386         truncate_ts(s->streams[pkt.stream_index], &pkt);
2387         ret= s->oformat->write_packet(s, &pkt);
2388
2389         av_free_packet(&pkt);
2390
2391         if(ret<0)
2392             goto fail;
2393         if(url_ferror(&s->pb))
2394             goto fail;
2395     }
2396
2397     if(s->oformat->write_trailer)
2398         ret = s->oformat->write_trailer(s);
2399 fail:
2400     if(ret == 0)
2401        ret=url_ferror(&s->pb);
2402     for(i=0;i<s->nb_streams;i++)
2403         av_freep(&s->streams[i]->priv_data);
2404     av_freep(&s->priv_data);
2405     return ret;
2406 }
2407
2408 /* "user interface" functions */
2409
2410 void dump_format(AVFormatContext *ic,
2411                  int index,
2412                  const char *url,
2413                  int is_output)
2414 {
2415     int i, flags;
2416     char buf[256];
2417
2418     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2419             is_output ? "Output" : "Input",
2420             index,
2421             is_output ? ic->oformat->name : ic->iformat->name,
2422             is_output ? "to" : "from", url);
2423     if (!is_output) {
2424         av_log(NULL, AV_LOG_INFO, "  Duration: ");
2425         if (ic->duration != AV_NOPTS_VALUE) {
2426             int hours, mins, secs, us;
2427             secs = ic->duration / AV_TIME_BASE;
2428             us = ic->duration % AV_TIME_BASE;
2429             mins = secs / 60;
2430             secs %= 60;
2431             hours = mins / 60;
2432             mins %= 60;
2433             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2434                    (10 * us) / AV_TIME_BASE);
2435         } else {
2436             av_log(NULL, AV_LOG_INFO, "N/A");
2437         }
2438         if (ic->start_time != AV_NOPTS_VALUE) {
2439             int secs, us;
2440             av_log(NULL, AV_LOG_INFO, ", start: ");
2441             secs = ic->start_time / AV_TIME_BASE;
2442             us = ic->start_time % AV_TIME_BASE;
2443             av_log(NULL, AV_LOG_INFO, "%d.%06d",
2444                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2445         }
2446         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2447         if (ic->bit_rate) {
2448             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2449         } else {
2450             av_log(NULL, AV_LOG_INFO, "N/A");
2451         }
2452         av_log(NULL, AV_LOG_INFO, "\n");
2453     }
2454     for(i=0;i<ic->nb_streams;i++) {
2455         AVStream *st = ic->streams[i];
2456         int g= ff_gcd(st->time_base.num, st->time_base.den);
2457         avcodec_string(buf, sizeof(buf), st->codec, is_output);
2458         av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d", index, i);
2459         /* the pid is an important information, so we display it */
2460         /* XXX: add a generic system */
2461         if (is_output)
2462             flags = ic->oformat->flags;
2463         else
2464             flags = ic->iformat->flags;
2465         if (flags & AVFMT_SHOW_IDS) {
2466             av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2467         }
2468         if (strlen(st->language) > 0) {
2469             av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2470         }
2471         av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2472         av_log(NULL, AV_LOG_INFO, ": %s", buf);
2473         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2474             if(st->r_frame_rate.den && st->r_frame_rate.num)
2475                 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2476 /*            else if(st->time_base.den && st->time_base.num)
2477                 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2478             else
2479                 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2480         }
2481         av_log(NULL, AV_LOG_INFO, "\n");
2482     }
2483 }
2484
2485 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2486 {
2487     return av_parse_video_frame_size(width_ptr, height_ptr, str);
2488 }
2489
2490 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2491 {
2492     AVRational frame_rate;
2493     int ret = av_parse_video_frame_rate(&frame_rate, arg);
2494     *frame_rate_num= frame_rate.num;
2495     *frame_rate_den= frame_rate.den;
2496     return ret;
2497 }
2498
2499 /**
2500  * gets the current time in micro seconds.
2501  */
2502 int64_t av_gettime(void)
2503 {
2504     struct timeval tv;
2505     gettimeofday(&tv,NULL);
2506     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2507 }
2508
2509 int64_t parse_date(const char *datestr, int duration)
2510 {
2511     const char *p;
2512     int64_t t;
2513     struct tm dt;
2514     int i;
2515     static const char *date_fmt[] = {
2516         "%Y-%m-%d",
2517         "%Y%m%d",
2518     };
2519     static const char *time_fmt[] = {
2520         "%H:%M:%S",
2521         "%H%M%S",
2522     };
2523     const char *q;
2524     int is_utc, len;
2525     char lastch;
2526     int negative = 0;
2527
2528 #undef time
2529     time_t now = time(0);
2530
2531     len = strlen(datestr);
2532     if (len > 0)
2533         lastch = datestr[len - 1];
2534     else
2535         lastch = '\0';
2536     is_utc = (lastch == 'z' || lastch == 'Z');
2537
2538     memset(&dt, 0, sizeof(dt));
2539
2540     p = datestr;
2541     q = NULL;
2542     if (!duration) {
2543         for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2544             q = small_strptime(p, date_fmt[i], &dt);
2545             if (q) {
2546                 break;
2547             }
2548         }
2549
2550         if (!q) {
2551             if (is_utc) {
2552                 dt = *gmtime(&now);
2553             } else {
2554                 dt = *localtime(&now);
2555             }
2556             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2557         } else {
2558             p = q;
2559         }
2560
2561         if (*p == 'T' || *p == 't' || *p == ' ')
2562             p++;
2563
2564         for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2565             q = small_strptime(p, time_fmt[i], &dt);
2566             if (q) {
2567                 break;
2568             }
2569         }
2570     } else {
2571         if (p[0] == '-') {
2572             negative = 1;
2573             ++p;
2574         }
2575         q = small_strptime(p, time_fmt[0], &dt);
2576         if (!q) {
2577             dt.tm_sec = strtol(p, (char **)&q, 10);
2578             dt.tm_min = 0;
2579             dt.tm_hour = 0;
2580         }
2581     }
2582
2583     /* Now we have all the fields that we can get */
2584     if (!q) {
2585         if (duration)
2586             return 0;
2587         else
2588             return now * INT64_C(1000000);
2589     }
2590
2591     if (duration) {
2592         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2593     } else {
2594         dt.tm_isdst = -1;       /* unknown */
2595         if (is_utc) {
2596             t = mktimegm(&dt);
2597         } else {
2598             t = mktime(&dt);
2599         }
2600     }
2601
2602     t *= 1000000;
2603
2604     if (*q == '.') {
2605         int val, n;
2606         q++;
2607         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2608             if (!isdigit(*q))
2609                 break;
2610             val += n * (*q - '0');
2611         }
2612         t += val;
2613     }
2614     return negative ? -t : t;
2615 }
2616
2617 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2618 {
2619     const char *p;
2620     char tag[128], *q;
2621
2622     p = info;
2623     if (*p == '?')
2624         p++;
2625     for(;;) {
2626         q = tag;
2627         while (*p != '\0' && *p != '=' && *p != '&') {
2628             if ((q - tag) < sizeof(tag) - 1)
2629                 *q++ = *p;
2630             p++;
2631         }
2632         *q = '\0';
2633         q = arg;
2634         if (*p == '=') {
2635             p++;
2636             while (*p != '&' && *p != '\0') {
2637                 if ((q - arg) < arg_size - 1) {
2638                     if (*p == '+')
2639                         *q++ = ' ';
2640                     else
2641                         *q++ = *p;
2642                 }
2643                 p++;
2644             }
2645             *q = '\0';
2646         }
2647         if (!strcmp(tag, tag1))
2648             return 1;
2649         if (*p != '&')
2650             break;
2651         p++;
2652     }
2653     return 0;
2654 }
2655
2656 int av_get_frame_filename(char *buf, int buf_size,
2657                           const char *path, int number)
2658 {
2659     const char *p;
2660     char *q, buf1[20], c;
2661     int nd, len, percentd_found;
2662
2663     q = buf;
2664     p = path;
2665     percentd_found = 0;
2666     for(;;) {
2667         c = *p++;
2668         if (c == '\0')
2669             break;
2670         if (c == '%') {
2671             do {
2672                 nd = 0;
2673                 while (isdigit(*p)) {
2674                     nd = nd * 10 + *p++ - '0';
2675                 }
2676                 c = *p++;
2677             } while (isdigit(c));
2678
2679             switch(c) {
2680             case '%':
2681                 goto addchar;
2682             case 'd':
2683                 if (percentd_found)
2684                     goto fail;
2685                 percentd_found = 1;
2686                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2687                 len = strlen(buf1);
2688                 if ((q - buf + len) > buf_size - 1)
2689                     goto fail;
2690                 memcpy(q, buf1, len);
2691                 q += len;
2692                 break;
2693             default:
2694                 goto fail;
2695             }
2696         } else {
2697         addchar:
2698             if ((q - buf) < buf_size - 1)
2699                 *q++ = c;
2700         }
2701     }
2702     if (!percentd_found)
2703         goto fail;
2704     *q = '\0';
2705     return 0;
2706  fail:
2707     *q = '\0';
2708     return -1;
2709 }
2710
2711 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2712 {
2713     int len, i, j, c;
2714 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2715
2716     for(i=0;i<size;i+=16) {
2717         len = size - i;
2718         if (len > 16)
2719             len = 16;
2720         PRINT("%08x ", i);
2721         for(j=0;j<16;j++) {
2722             if (j < len)
2723                 PRINT(" %02x", buf[i+j]);
2724             else
2725                 PRINT("   ");
2726         }
2727         PRINT(" ");
2728         for(j=0;j<len;j++) {
2729             c = buf[i+j];
2730             if (c < ' ' || c > '~')
2731                 c = '.';
2732             PRINT("%c", c);
2733         }
2734         PRINT("\n");
2735     }
2736 #undef PRINT
2737 }
2738
2739 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2740 {
2741     hex_dump_internal(NULL, f, 0, buf, size);
2742 }
2743
2744 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2745 {
2746     hex_dump_internal(avcl, NULL, level, buf, size);
2747 }
2748
2749  //FIXME needs to know the time_base
2750 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2751 {
2752 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2753     PRINT("stream #%d:\n", pkt->stream_index);
2754     PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2755     PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2756     /* DTS is _always_ valid after av_read_frame() */
2757     PRINT("  dts=");
2758     if (pkt->dts == AV_NOPTS_VALUE)
2759         PRINT("N/A");
2760     else
2761         PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2762     /* PTS may be not known if B frames are present */
2763     PRINT("  pts=");
2764     if (pkt->pts == AV_NOPTS_VALUE)
2765         PRINT("N/A");
2766     else
2767         PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2768     PRINT("\n");
2769     PRINT("  size=%d\n", pkt->size);
2770 #undef PRINT
2771     if (dump_payload)
2772         av_hex_dump(f, pkt->data, pkt->size);
2773 }
2774
2775 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2776 {
2777     pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2778 }
2779
2780 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2781 {
2782     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2783 }
2784
2785 void url_split(char *proto, int proto_size,
2786                char *authorization, int authorization_size,
2787                char *hostname, int hostname_size,
2788                int *port_ptr,
2789                char *path, int path_size,
2790                const char *url)
2791 {
2792     const char *p;
2793     char *q;
2794     int port;
2795
2796     port = -1;
2797
2798     p = url;
2799     q = proto;
2800     while (*p != ':' && *p != '\0') {
2801         if ((q - proto) < proto_size - 1)
2802             *q++ = *p;
2803         p++;
2804     }
2805     if (proto_size > 0)
2806         *q = '\0';
2807     if (authorization_size > 0)
2808         authorization[0] = '\0';
2809     if (*p == '\0') {
2810         if (proto_size > 0)
2811             proto[0] = '\0';
2812         if (hostname_size > 0)
2813             hostname[0] = '\0';
2814         p = url;
2815     } else {
2816         char *at,*slash; // PETR: position of '@' character and '/' character
2817
2818         p++;
2819         if (*p == '/')
2820             p++;
2821         if (*p == '/')
2822             p++;
2823         at = strchr(p,'@'); // PETR: get the position of '@'
2824         slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2825         if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2826
2827         q = at ? authorization : hostname;  // PETR: if '@' exists starting with auth.
2828
2829          while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2830             if (*p == '@') {    // PETR: passed '@'
2831               if (authorization_size > 0)
2832                   *q = '\0';
2833               q = hostname;
2834               at = NULL;
2835             } else if (!at) {   // PETR: hostname
2836               if ((q - hostname) < hostname_size - 1)
2837                   *q++ = *p;
2838             } else {
2839               if ((q - authorization) < authorization_size - 1)
2840                 *q++ = *p;
2841             }
2842             p++;
2843         }
2844         if (hostname_size > 0)
2845             *q = '\0';
2846         if (*p == ':') {
2847             p++;
2848             port = strtoul(p, (char **)&p, 10);
2849         }
2850     }
2851     if (port_ptr)
2852         *port_ptr = port;
2853     av_strlcpy(path, p, path_size);
2854 }
2855
2856 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2857                      int pts_num, int pts_den)
2858 {
2859     s->pts_wrap_bits = pts_wrap_bits;
2860     s->time_base.num = pts_num;
2861     s->time_base.den = pts_den;
2862 }
2863
2864 /* fraction handling */
2865
2866 /**
2867  * f = val + (num / den) + 0.5.
2868  *
2869  * 'num' is normalized so that it is such as 0 <= num < den.
2870  *
2871  * @param f fractional number
2872  * @param val integer value
2873  * @param num must be >= 0
2874  * @param den must be >= 1
2875  */
2876 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2877 {
2878     num += (den >> 1);
2879     if (num >= den) {
2880         val += num / den;
2881         num = num % den;
2882     }
2883     f->val = val;
2884     f->num = num;
2885     f->den = den;
2886 }
2887
2888 /**
2889  * Fractionnal addition to f: f = f + (incr / f->den).
2890  *
2891  * @param f fractional number
2892  * @param incr increment, can be positive or negative
2893  */
2894 static void av_frac_add(AVFrac *f, int64_t incr)
2895 {
2896     int64_t num, den;
2897
2898     num = f->num + incr;
2899     den = f->den;
2900     if (num < 0) {
2901         f->val += num / den;
2902         num = num % den;
2903         if (num < 0) {
2904             num += den;
2905             f->val--;
2906         }
2907     } else if (num >= den) {
2908         f->val += num / den;
2909         num = num % den;
2910     }
2911     f->num = num;
2912 }