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