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