98110ab4b4915870b117df46d058f9ec9245c7e6
[ffmpeg.git] / libavformat / utils.c
1 /*
2  * Various utilities for ffmpeg system
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Lesser General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public
16  * License along with this library; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  */
19 #include "avformat.h"
20
21 #undef NDEBUG
22 #include <assert.h>
23
24 AVInputFormat *first_iformat;
25 AVOutputFormat *first_oformat;
26 AVImageFormat *first_image_format;
27
28 void av_register_input_format(AVInputFormat *format)
29 {
30     AVInputFormat **p;
31     p = &first_iformat;
32     while (*p != NULL) p = &(*p)->next;
33     *p = format;
34     format->next = NULL;
35 }
36
37 void av_register_output_format(AVOutputFormat *format)
38 {
39     AVOutputFormat **p;
40     p = &first_oformat;
41     while (*p != NULL) p = &(*p)->next;
42     *p = format;
43     format->next = NULL;
44 }
45
46 int match_ext(const char *filename, const char *extensions)
47 {
48     const char *ext, *p;
49     char ext1[32], *q;
50
51     if(!filename)
52         return 0;
53     
54     ext = strrchr(filename, '.');
55     if (ext) {
56         ext++;
57         p = extensions;
58         for(;;) {
59             q = ext1;
60             while (*p != '\0' && *p != ',') 
61                 *q++ = *p++;
62             *q = '\0';
63             if (!strcasecmp(ext1, ext)) 
64                 return 1;
65             if (*p == '\0') 
66                 break;
67             p++;
68         }
69     }
70     return 0;
71 }
72
73 AVOutputFormat *guess_format(const char *short_name, const char *filename, 
74                              const char *mime_type)
75 {
76     AVOutputFormat *fmt, *fmt_found;
77     int score_max, score;
78
79     /* specific test for image sequences */
80     if (!short_name && filename && 
81         filename_number_test(filename) >= 0 &&
82         guess_image_format(filename)) {
83         return guess_format("image", NULL, NULL);
84     }
85
86     /* find the proper file type */
87     fmt_found = NULL;
88     score_max = 0;
89     fmt = first_oformat;
90     while (fmt != NULL) {
91         score = 0;
92         if (fmt->name && short_name && !strcmp(fmt->name, short_name))
93             score += 100;
94         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
95             score += 10;
96         if (filename && fmt->extensions && 
97             match_ext(filename, fmt->extensions)) {
98             score += 5;
99         }
100         if (score > score_max) {
101             score_max = score;
102             fmt_found = fmt;
103         }
104         fmt = fmt->next;
105     }
106     return fmt_found;
107 }   
108
109 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename, 
110                              const char *mime_type)
111 {
112     AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
113
114     if (fmt) {
115         AVOutputFormat *stream_fmt;
116         char stream_format_name[64];
117
118         snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
119         stream_fmt = guess_format(stream_format_name, NULL, NULL);
120
121         if (stream_fmt)
122             fmt = stream_fmt;
123     }
124
125     return fmt;
126 }
127
128 AVInputFormat *av_find_input_format(const char *short_name)
129 {
130     AVInputFormat *fmt;
131     for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
132         if (!strcmp(fmt->name, short_name))
133             return fmt;
134     }
135     return NULL;
136 }
137
138 /* memory handling */
139
140 /**
141  * Default packet destructor 
142  */
143 static void av_destruct_packet(AVPacket *pkt)
144 {
145     av_free(pkt->data);
146     pkt->data = NULL; pkt->size = 0;
147 }
148
149 /**
150  * Allocate the payload of a packet and intialized its fields to default values.
151  *
152  * @param pkt packet
153  * @param size wanted payload size
154  * @return 0 if OK. AVERROR_xxx otherwise.
155  */
156 int av_new_packet(AVPacket *pkt, int size)
157 {
158     void *data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
159     if (!data)
160         return AVERROR_NOMEM;
161     memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
162
163     av_init_packet(pkt);
164     pkt->data = data; 
165     pkt->size = size;
166     pkt->destruct = av_destruct_packet;
167     return 0;
168 }
169
170 /* This is a hack - the packet memory allocation stuff is broken. The
171    packet is allocated if it was not really allocated */
172 int av_dup_packet(AVPacket *pkt)
173 {
174     if (pkt->destruct != av_destruct_packet) {
175         uint8_t *data;
176         /* we duplicate the packet and don't forget to put the padding
177            again */
178         data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
179         if (!data) {
180             return AVERROR_NOMEM;
181         }
182         memcpy(data, pkt->data, pkt->size);
183         memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
184         pkt->data = data;
185         pkt->destruct = av_destruct_packet;
186     }
187     return 0;
188 }
189
190 /* fifo handling */
191
192 int fifo_init(FifoBuffer *f, int size)
193 {
194     f->buffer = av_malloc(size);
195     if (!f->buffer)
196         return -1;
197     f->end = f->buffer + size;
198     f->wptr = f->rptr = f->buffer;
199     return 0;
200 }
201
202 void fifo_free(FifoBuffer *f)
203 {
204     av_free(f->buffer);
205 }
206
207 int fifo_size(FifoBuffer *f, uint8_t *rptr)
208 {
209     int size;
210
211     if (f->wptr >= rptr) {
212         size = f->wptr - rptr;
213     } else {
214         size = (f->end - rptr) + (f->wptr - f->buffer);
215     }
216     return size;
217 }
218
219 /* get data from the fifo (return -1 if not enough data) */
220 int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
221 {
222     uint8_t *rptr = *rptr_ptr;
223     int size, len;
224
225     if (f->wptr >= rptr) {
226         size = f->wptr - rptr;
227     } else {
228         size = (f->end - rptr) + (f->wptr - f->buffer);
229     }
230     
231     if (size < buf_size)
232         return -1;
233     while (buf_size > 0) {
234         len = f->end - rptr;
235         if (len > buf_size)
236             len = buf_size;
237         memcpy(buf, rptr, len);
238         buf += len;
239         rptr += len;
240         if (rptr >= f->end)
241             rptr = f->buffer;
242         buf_size -= len;
243     }
244     *rptr_ptr = rptr;
245     return 0;
246 }
247
248 void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
249 {
250     int len;
251     uint8_t *wptr;
252     wptr = *wptr_ptr;
253     while (size > 0) {
254         len = f->end - wptr;
255         if (len > size)
256             len = size;
257         memcpy(wptr, buf, len);
258         wptr += len;
259         if (wptr >= f->end)
260             wptr = f->buffer;
261         buf += len;
262         size -= len;
263     }
264     *wptr_ptr = wptr;
265 }
266
267 int filename_number_test(const char *filename)
268 {
269     char buf[1024];
270     if(!filename)
271         return -1;
272     return get_frame_filename(buf, sizeof(buf), filename, 1);
273 }
274
275 /* guess file format */
276 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
277 {
278     AVInputFormat *fmt1, *fmt;
279     int score, score_max;
280
281     fmt = NULL;
282     score_max = 0;
283     for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
284         if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
285             continue;
286         score = 0;
287         if (fmt1->read_probe) {
288             score = fmt1->read_probe(pd);
289         } else if (fmt1->extensions) {
290             if (match_ext(pd->filename, fmt1->extensions)) {
291                 score = 50;
292             }
293         } 
294         if (score > score_max) {
295             score_max = score;
296             fmt = fmt1;
297         }
298     }
299     return fmt;
300 }
301
302 /************************************************************/
303 /* input media file */
304
305 /**
306  * open a media file from an IO stream. 'fmt' must be specified.
307  */
308
309 static const char* format_to_name(void* ptr)
310 {
311     AVFormatContext* fc = (AVFormatContext*) ptr;
312     if(fc->iformat) return fc->iformat->name;
313     else if(fc->oformat) return fc->oformat->name;
314     else return "NULL";
315 }
316
317 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
318
319 AVFormatContext *av_alloc_format_context(void)
320 {
321     AVFormatContext *ic;
322     ic = av_mallocz(sizeof(AVFormatContext));
323     if (!ic) return ic;
324     ic->av_class = &av_format_context_class;
325     return ic;
326 }
327
328 int av_open_input_stream(AVFormatContext **ic_ptr, 
329                          ByteIOContext *pb, const char *filename, 
330                          AVInputFormat *fmt, AVFormatParameters *ap)
331 {
332     int err;
333     AVFormatContext *ic;
334
335     ic = av_alloc_format_context();
336     if (!ic) {
337         err = AVERROR_NOMEM;
338         goto fail;
339     }
340     ic->iformat = fmt;
341     if (pb)
342         ic->pb = *pb;
343     ic->duration = AV_NOPTS_VALUE;
344     ic->start_time = AV_NOPTS_VALUE;
345     pstrcpy(ic->filename, sizeof(ic->filename), filename);
346
347     /* allocate private data */
348     if (fmt->priv_data_size > 0) {
349         ic->priv_data = av_mallocz(fmt->priv_data_size);
350         if (!ic->priv_data) {
351             err = AVERROR_NOMEM;
352             goto fail;
353         }
354     } else {
355         ic->priv_data = NULL;
356     }
357
358     err = ic->iformat->read_header(ic, ap);
359     if (err < 0)
360         goto fail;
361
362     if (pb)
363         ic->data_offset = url_ftell(&ic->pb);
364
365     *ic_ptr = ic;
366     return 0;
367  fail:
368     if (ic) {
369         av_freep(&ic->priv_data);
370     }
371     av_free(ic);
372     *ic_ptr = NULL;
373     return err;
374 }
375
376 #define PROBE_BUF_SIZE 2048
377
378 /**
379  * Open a media file as input. The codec are not opened. Only the file
380  * header (if present) is read.
381  *
382  * @param ic_ptr the opened media file handle is put here
383  * @param filename filename to open.
384  * @param fmt if non NULL, force the file format to use
385  * @param buf_size optional buffer size (zero if default is OK)
386  * @param ap additionnal parameters needed when opening the file (NULL if default)
387  * @return 0 if OK. AVERROR_xxx otherwise.
388  */
389 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename, 
390                        AVInputFormat *fmt,
391                        int buf_size,
392                        AVFormatParameters *ap)
393 {
394     int err, must_open_file, file_opened;
395     uint8_t buf[PROBE_BUF_SIZE];
396     AVProbeData probe_data, *pd = &probe_data;
397     ByteIOContext pb1, *pb = &pb1;
398     
399     file_opened = 0;
400     pd->filename = "";
401     if (filename)
402         pd->filename = filename;
403     pd->buf = buf;
404     pd->buf_size = 0;
405
406     if (!fmt) {
407         /* guess format if no file can be opened  */
408         fmt = av_probe_input_format(pd, 0);
409     }
410
411     /* do not open file if the format does not need it. XXX: specific
412        hack needed to handle RTSP/TCP */
413     must_open_file = 1;
414     if (fmt && (fmt->flags & AVFMT_NOFILE)) {
415         must_open_file = 0;
416     }
417
418     if (!fmt || must_open_file) {
419         /* if no file needed do not try to open one */
420         if (url_fopen(pb, filename, URL_RDONLY) < 0) {
421             err = AVERROR_IO;
422             goto fail;
423         }
424         file_opened = 1;
425         if (buf_size > 0) {
426             url_setbufsize(pb, buf_size);
427         }
428         if (!fmt) {
429             /* read probe data */
430             pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
431             url_fseek(pb, 0, SEEK_SET);
432         }
433     }
434     
435     /* guess file format */
436     if (!fmt) {
437         fmt = av_probe_input_format(pd, 1);
438     }
439
440     /* if still no format found, error */
441     if (!fmt) {
442         err = AVERROR_NOFMT;
443         goto fail;
444     }
445         
446     /* XXX: suppress this hack for redirectors */
447 #ifdef CONFIG_NETWORK
448     if (fmt == &redir_demux) {
449         err = redir_open(ic_ptr, pb);
450         url_fclose(pb);
451         return err;
452     }
453 #endif
454
455     /* check filename in case of an image number is expected */
456     if (fmt->flags & AVFMT_NEEDNUMBER) {
457         if (filename_number_test(filename) < 0) { 
458             err = AVERROR_NUMEXPECTED;
459             goto fail;
460         }
461     }
462     err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
463     if (err)
464         goto fail;
465     return 0;
466  fail:
467     if (file_opened)
468         url_fclose(pb);
469     *ic_ptr = NULL;
470     return err;
471     
472 }
473
474 /*******************************************************/
475
476 /**
477  * Read a transport packet from a media file. This function is
478  * absolete and should never be used. Use av_read_frame() instead.
479  * 
480  * @param s media file handle
481  * @param pkt is filled 
482  * @return 0 if OK. AVERROR_xxx if error.  
483  */
484 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
485 {
486     return s->iformat->read_packet(s, pkt);
487 }
488
489 /**********************************************************/
490
491 /* convert the packet time stamp units and handle wrapping. The
492    wrapping is handled by considering the next PTS/DTS as a delta to
493    the previous value. We handle the delta as a fraction to avoid any
494    rounding errors. */
495 static inline int64_t convert_timestamp_units(AVStream *s,
496                                         int64_t *plast_pkt_pts,
497                                         int *plast_pkt_pts_frac,
498                                         int64_t *plast_pkt_stream_pts,
499                                         int64_t pts)
500 {
501     int64_t stream_pts;
502     int64_t delta_pts;
503     int shift, pts_frac;
504
505     if (pts != AV_NOPTS_VALUE) {
506         stream_pts = pts;
507         if (*plast_pkt_stream_pts != AV_NOPTS_VALUE) {
508             shift = 64 - s->pts_wrap_bits;
509             delta_pts = ((stream_pts - *plast_pkt_stream_pts) << shift) >> shift;
510             /* XXX: overflow possible but very unlikely as it is a delta */
511             delta_pts = delta_pts * AV_TIME_BASE * s->time_base.num;
512             pts = *plast_pkt_pts + (delta_pts / s->time_base.den);
513             pts_frac = *plast_pkt_pts_frac + (delta_pts % s->time_base.den);
514             if (pts_frac >= s->time_base.den) {
515                 pts_frac -= s->time_base.den;
516                 pts++;
517             }
518         } else {
519             /* no previous pts, so no wrapping possible */
520 //            pts = av_rescale(stream_pts, (int64_t)AV_TIME_BASE * s->time_base.num, s->time_base.den);
521             pts = (int64_t)(((double)stream_pts * AV_TIME_BASE * s->time_base.num) / 
522                             (double)s->time_base.den);
523             pts_frac = 0;
524         }
525         *plast_pkt_stream_pts = stream_pts;
526         *plast_pkt_pts = pts;
527         *plast_pkt_pts_frac = pts_frac;
528     }
529     return pts;
530 }
531
532 /* get the number of samples of an audio frame. Return (-1) if error */
533 static int get_audio_frame_size(AVCodecContext *enc, int size)
534 {
535     int frame_size;
536
537     if (enc->frame_size <= 1) {
538         /* specific hack for pcm codecs because no frame size is
539            provided */
540         switch(enc->codec_id) {
541         case CODEC_ID_PCM_S16LE:
542         case CODEC_ID_PCM_S16BE:
543         case CODEC_ID_PCM_U16LE:
544         case CODEC_ID_PCM_U16BE:
545             if (enc->channels == 0)
546                 return -1;
547             frame_size = size / (2 * enc->channels);
548             break;
549         case CODEC_ID_PCM_S8:
550         case CODEC_ID_PCM_U8:
551         case CODEC_ID_PCM_MULAW:
552         case CODEC_ID_PCM_ALAW:
553             if (enc->channels == 0)
554                 return -1;
555             frame_size = size / (enc->channels);
556             break;
557         default:
558             /* used for example by ADPCM codecs */
559             if (enc->bit_rate == 0)
560                 return -1;
561             frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
562             break;
563         }
564     } else {
565         frame_size = enc->frame_size;
566     }
567     return frame_size;
568 }
569
570
571 /* return the frame duration in seconds, return 0 if not available */
572 static void compute_frame_duration(int *pnum, int *pden,
573                                    AVFormatContext *s, AVStream *st, 
574                                    AVCodecParserContext *pc, AVPacket *pkt)
575 {
576     int frame_size;
577
578     *pnum = 0;
579     *pden = 0;
580     switch(st->codec.codec_type) {
581     case CODEC_TYPE_VIDEO:
582         *pnum = st->codec.frame_rate_base;
583         *pden = st->codec.frame_rate;
584         if (pc && pc->repeat_pict) {
585             *pden *= 2;
586             *pnum = (*pnum) * (2 + pc->repeat_pict);
587         }
588         break;
589     case CODEC_TYPE_AUDIO:
590         frame_size = get_audio_frame_size(&st->codec, pkt->size);
591         if (frame_size < 0)
592             break;
593         *pnum = frame_size;
594         *pden = st->codec.sample_rate;
595         break;
596     default:
597         break;
598     }
599 }
600
601 static void compute_pkt_fields(AVFormatContext *s, AVStream *st, 
602                                AVCodecParserContext *pc, AVPacket *pkt)
603 {
604     int num, den, presentation_delayed;
605
606     if (pkt->duration == 0) {
607         compute_frame_duration(&num, &den, s, st, pc, pkt);
608         if (den && num) {
609             pkt->duration = (num * (int64_t)AV_TIME_BASE) / den;
610         }
611     }
612
613     /* do we have a video B frame ? */
614     presentation_delayed = 0;
615     if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
616         /* XXX: need has_b_frame, but cannot get it if the codec is
617            not initialized */
618         if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
619              st->codec.codec_id == CODEC_ID_MPEG2VIDEO ||
620              st->codec.codec_id == CODEC_ID_MPEG4 ||
621              st->codec.codec_id == CODEC_ID_H264) && 
622             pc && pc->pict_type != FF_B_TYPE)
623             presentation_delayed = 1;
624     }
625
626     /* interpolate PTS and DTS if they are not present */
627     if (presentation_delayed) {
628         /* DTS = decompression time stamp */
629         /* PTS = presentation time stamp */
630         if (pkt->dts == AV_NOPTS_VALUE) {
631             pkt->dts = st->cur_dts;
632         } else {
633             st->cur_dts = pkt->dts;
634         }
635         /* this is tricky: the dts must be incremented by the duration
636            of the frame we are displaying, i.e. the last I or P frame */
637         if (st->last_IP_duration == 0)
638             st->cur_dts += pkt->duration;
639         else
640             st->cur_dts += st->last_IP_duration;
641         st->last_IP_duration  = pkt->duration;
642         /* cannot compute PTS if not present (we can compute it only
643            by knowing the futur */
644     } else {
645         /* presentation is not delayed : PTS and DTS are the same */
646         if (pkt->pts == AV_NOPTS_VALUE) {
647             if (pkt->dts == AV_NOPTS_VALUE) {
648                 pkt->pts = st->cur_dts;
649                 pkt->dts = st->cur_dts;
650             }
651             else {
652                 st->cur_dts = pkt->dts;
653                 pkt->pts = pkt->dts;
654             }
655         } else {
656             st->cur_dts = pkt->pts;
657             pkt->dts = pkt->pts;
658         }
659         st->cur_dts += pkt->duration;
660     }
661     
662     /* update flags */
663     if (pc) {
664         pkt->flags = 0;
665         /* key frame computation */
666         switch(st->codec.codec_type) {
667         case CODEC_TYPE_VIDEO:
668             if (pc->pict_type == FF_I_TYPE)
669                 pkt->flags |= PKT_FLAG_KEY;
670             break;
671         case CODEC_TYPE_AUDIO:
672             pkt->flags |= PKT_FLAG_KEY;
673             break;
674         default:
675             break;
676         }
677     }
678
679 }
680
681 static void av_destruct_packet_nofree(AVPacket *pkt)
682 {
683     pkt->data = NULL; pkt->size = 0;
684 }
685
686 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
687 {
688     AVStream *st;
689     int len, ret, i;
690
691     for(;;) {
692         /* select current input stream component */
693         st = s->cur_st;
694         if (st) {
695             if (!st->parser) {
696                 /* no parsing needed: we just output the packet as is */
697                 /* raw data support */
698                 *pkt = s->cur_pkt;
699                 compute_pkt_fields(s, st, NULL, pkt);
700                 s->cur_st = NULL;
701                 return 0;
702             } else if (s->cur_len > 0) {
703                 len = av_parser_parse(st->parser, &st->codec, &pkt->data, &pkt->size, 
704                                       s->cur_ptr, s->cur_len,
705                                       s->cur_pkt.pts, s->cur_pkt.dts);
706                 s->cur_pkt.pts = AV_NOPTS_VALUE;
707                 s->cur_pkt.dts = AV_NOPTS_VALUE;
708                 /* increment read pointer */
709                 s->cur_ptr += len;
710                 s->cur_len -= len;
711                 
712                 /* return packet if any */
713                 if (pkt->size) {
714                 got_packet:
715                     pkt->duration = 0;
716                     pkt->stream_index = st->index;
717                     pkt->pts = st->parser->pts;
718                     pkt->dts = st->parser->dts;
719                     pkt->destruct = av_destruct_packet_nofree;
720                     compute_pkt_fields(s, st, st->parser, pkt);
721                     return 0;
722                 }
723             } else {
724                 /* free packet */
725                 av_free_packet(&s->cur_pkt); 
726                 s->cur_st = NULL;
727             }
728         } else {
729             /* read next packet */
730             ret = av_read_packet(s, &s->cur_pkt);
731             if (ret < 0) {
732                 if (ret == -EAGAIN)
733                     return ret;
734                 /* return the last frames, if any */
735                 for(i = 0; i < s->nb_streams; i++) {
736                     st = s->streams[i];
737                     if (st->parser) {
738                         av_parser_parse(st->parser, &st->codec, 
739                                         &pkt->data, &pkt->size, 
740                                         NULL, 0, 
741                                         AV_NOPTS_VALUE, AV_NOPTS_VALUE);
742                         if (pkt->size)
743                             goto got_packet;
744                     }
745                 }
746                 /* no more packets: really terminates parsing */
747                 return ret;
748             }
749             
750             st = s->streams[s->cur_pkt.stream_index];
751
752             /* convert the packet time stamp units and handle wrapping */
753             s->cur_pkt.pts = convert_timestamp_units(st, 
754                                                &st->last_pkt_pts, &st->last_pkt_pts_frac,
755                                                &st->last_pkt_stream_pts,
756                                                s->cur_pkt.pts);
757             s->cur_pkt.dts = convert_timestamp_units(st, 
758                                                &st->last_pkt_dts,  &st->last_pkt_dts_frac,
759                                                &st->last_pkt_stream_dts,
760                                                s->cur_pkt.dts);
761 #if 0
762             if (s->cur_pkt.stream_index == 0) {
763                 if (s->cur_pkt.pts != AV_NOPTS_VALUE) 
764                     printf("PACKET pts=%0.3f\n", 
765                            (double)s->cur_pkt.pts / AV_TIME_BASE);
766                 if (s->cur_pkt.dts != AV_NOPTS_VALUE) 
767                     printf("PACKET dts=%0.3f\n", 
768                            (double)s->cur_pkt.dts / AV_TIME_BASE);
769             }
770 #endif
771
772             /* duration field */
773             s->cur_pkt.duration = av_rescale(s->cur_pkt.duration, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
774
775             s->cur_st = st;
776             s->cur_ptr = s->cur_pkt.data;
777             s->cur_len = s->cur_pkt.size;
778             if (st->need_parsing && !st->parser) {
779                 st->parser = av_parser_init(st->codec.codec_id);
780                 if (!st->parser) {
781                     /* no parser available : just output the raw packets */
782                     st->need_parsing = 0;
783                 }
784             }
785         }
786     }
787 }
788
789 /**
790  * Return the next frame of a stream. The returned packet is valid
791  * until the next av_read_frame() or until av_close_input_file() and
792  * must be freed with av_free_packet. For video, the packet contains
793  * exactly one frame. For audio, it contains an integer number of
794  * frames if each frame has a known fixed size (e.g. PCM or ADPCM
795  * data). If the audio frames have a variable size (e.g. MPEG audio),
796  * then it contains one frame.
797  * 
798  * pkt->pts, pkt->dts and pkt->duration are always set to correct
799  * values in AV_TIME_BASE unit (and guessed if the format cannot
800  * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
801  * has B frames, so it is better to rely on pkt->dts if you do not
802  * decompress the payload.
803  * 
804  * Return 0 if OK, < 0 if error or end of file.  
805  */
806 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
807 {
808     AVPacketList *pktl;
809
810     pktl = s->packet_buffer;
811     if (pktl) {
812         /* read packet from packet buffer, if there is data */
813         *pkt = pktl->pkt;
814         s->packet_buffer = pktl->next;
815         av_free(pktl);
816         return 0;
817     } else {
818         return av_read_frame_internal(s, pkt);
819     }
820 }
821
822 /* XXX: suppress the packet queue */
823 static void flush_packet_queue(AVFormatContext *s)
824 {
825     AVPacketList *pktl;
826
827     for(;;) {
828         pktl = s->packet_buffer;
829         if (!pktl) 
830             break;
831         s->packet_buffer = pktl->next;
832         av_free_packet(&pktl->pkt);
833         av_free(pktl);
834     }
835 }
836
837 /*******************************************************/
838 /* seek support */
839
840 int av_find_default_stream_index(AVFormatContext *s)
841 {
842     int i;
843     AVStream *st;
844
845     if (s->nb_streams <= 0)
846         return -1;
847     for(i = 0; i < s->nb_streams; i++) {
848         st = s->streams[i];
849         if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
850             return i;
851         }
852     }
853     return 0;
854 }
855
856 /* flush the frame reader */
857 static void av_read_frame_flush(AVFormatContext *s)
858 {
859     AVStream *st;
860     int i;
861
862     flush_packet_queue(s);
863
864     /* free previous packet */
865     if (s->cur_st) {
866         if (s->cur_st->parser)
867             av_free_packet(&s->cur_pkt);
868         s->cur_st = NULL;
869     }
870     /* fail safe */
871     s->cur_ptr = NULL;
872     s->cur_len = 0;
873     
874     /* for each stream, reset read state */
875     for(i = 0; i < s->nb_streams; i++) {
876         st = s->streams[i];
877         
878         if (st->parser) {
879             av_parser_close(st->parser);
880             st->parser = NULL;
881         }
882         st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
883     }
884 }
885
886 /* add a index entry into a sorted list updateing if it is already there */
887 int av_add_index_entry(AVStream *st,
888                             int64_t pos, int64_t timestamp, int distance, int flags)
889 {
890     AVIndexEntry *entries, *ie;
891     int index;
892     
893     entries = av_fast_realloc(st->index_entries,
894                               &st->index_entries_allocated_size,
895                               (st->nb_index_entries + 1) * 
896                               sizeof(AVIndexEntry));
897     st->index_entries= entries;
898
899     if(st->nb_index_entries){
900         index= av_index_search_timestamp(st, timestamp);
901         ie= &entries[index];
902
903         if(ie->timestamp != timestamp){
904             if(ie->timestamp < timestamp){
905                 index++; //index points to next instead of previous entry, maybe nonexistant
906                 ie= &st->index_entries[index];
907             }else
908                 assert(index==0);
909                 
910             if(index != st->nb_index_entries){
911                 assert(index < st->nb_index_entries);
912                 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
913             }
914             st->nb_index_entries++;
915         }else{
916             if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
917                 distance= ie->min_distance;
918         }
919     }else{
920         index= st->nb_index_entries++;
921         ie= &entries[index];
922     }
923     
924     ie->pos = pos;
925     ie->timestamp = timestamp;
926     ie->min_distance= distance;
927     ie->flags = flags;
928     
929     return index;
930 }
931
932 /* build an index for raw streams using a parser */
933 static void av_build_index_raw(AVFormatContext *s)
934 {
935     AVPacket pkt1, *pkt = &pkt1;
936     int ret;
937     AVStream *st;
938
939     st = s->streams[0];
940     av_read_frame_flush(s);
941     url_fseek(&s->pb, s->data_offset, SEEK_SET);
942
943     for(;;) {
944         ret = av_read_frame(s, pkt);
945         if (ret < 0)
946             break;
947         if (pkt->stream_index == 0 && st->parser &&
948             (pkt->flags & PKT_FLAG_KEY)) {
949             av_add_index_entry(st, st->parser->frame_offset, pkt->dts, 
950                             0, AVINDEX_KEYFRAME);
951         }
952         av_free_packet(pkt);
953     }
954 }
955
956 /* return TRUE if we deal with a raw stream (raw codec data and
957    parsing needed) */
958 static int is_raw_stream(AVFormatContext *s)
959 {
960     AVStream *st;
961
962     if (s->nb_streams != 1)
963         return 0;
964     st = s->streams[0];
965     if (!st->need_parsing)
966         return 0;
967     return 1;
968 }
969
970 /* return the largest index entry whose timestamp is <=
971    wanted_timestamp */
972 int av_index_search_timestamp(AVStream *st, int wanted_timestamp)
973 {
974     AVIndexEntry *entries= st->index_entries;
975     int nb_entries= st->nb_index_entries;
976     int a, b, m;
977     int64_t timestamp;
978
979     if (nb_entries <= 0)
980         return -1;
981     
982     a = 0;
983     b = nb_entries - 1;
984
985     while (a < b) {
986         m = (a + b + 1) >> 1;
987         timestamp = entries[m].timestamp;
988         if (timestamp > wanted_timestamp) {
989             b = m - 1;
990         } else {
991             a = m;
992         }
993     }
994     return a;
995 }
996
997 #define DEBUG_SEEK
998
999 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts){
1000     AVInputFormat *avif= s->iformat;
1001     int64_t pos_min, pos_max, pos, pos_limit;
1002     int64_t ts_min, ts_max, ts;
1003     int64_t start_pos;
1004     int index, no_change;
1005     AVStream *st;
1006
1007     if (stream_index < 0) {
1008         stream_index = av_find_default_stream_index(s);
1009         if (stream_index < 0)
1010             return -1;
1011     }
1012
1013 #ifdef DEBUG_SEEK
1014     av_log(s, AV_LOG_DEBUG, "read_seek: %d %lld\n", stream_index, target_ts);
1015 #endif
1016
1017     ts_max=
1018     ts_min= AV_NOPTS_VALUE;
1019     pos_limit= -1; //gcc falsely says it may be uninitalized
1020
1021     st= s->streams[stream_index];
1022     if(st->index_entries){
1023         AVIndexEntry *e;
1024
1025         index= av_index_search_timestamp(st, target_ts);
1026         e= &st->index_entries[index];
1027
1028         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1029             pos_min= e->pos;
1030             ts_min= e->timestamp;
1031 #ifdef DEBUG_SEEK
1032         av_log(s, AV_LOG_DEBUG, "unsing cached pos_min=0x%llx dts_min=%lld\n", 
1033                pos_min,ts_min);
1034 #endif
1035         }else{
1036             assert(index==0);
1037         }
1038         index++;
1039         if(index < st->nb_index_entries){
1040             e= &st->index_entries[index];
1041             assert(e->timestamp >= target_ts);
1042             pos_max= e->pos;
1043             ts_max= e->timestamp;
1044             pos_limit= pos_max - e->min_distance;
1045 #ifdef DEBUG_SEEK
1046         av_log(s, AV_LOG_DEBUG, "unsing cached pos_max=0x%llx pos_limit=0x%llx dts_max=%lld\n", 
1047                pos_max,pos_limit, ts_max);
1048 #endif
1049         }
1050     }
1051
1052     if(ts_min == AV_NOPTS_VALUE){
1053         pos_min = s->data_offset;
1054         ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1055         if (ts_min == AV_NOPTS_VALUE)
1056             return -1;
1057     }
1058
1059     if(ts_max == AV_NOPTS_VALUE){
1060         int step= 1024;
1061         pos_max = url_filesize(url_fileno(&s->pb)) - 1;
1062         do{
1063             pos_max -= step;
1064             ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1065             step += step;
1066         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1067         if (ts_max == AV_NOPTS_VALUE)
1068             return -1;
1069         
1070         for(;;){
1071             int64_t tmp_pos= pos_max + 1;
1072             int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1073             if(tmp_ts == AV_NOPTS_VALUE)
1074                 break;
1075             ts_max= tmp_ts;
1076             pos_max= tmp_pos;
1077         }
1078         pos_limit= pos_max;
1079     }
1080
1081     no_change=0;
1082     while (pos_min < pos_limit) {
1083 #ifdef DEBUG_SEEK
1084         av_log(s, AV_LOG_DEBUG, "pos_min=0x%llx pos_max=0x%llx dts_min=%lld dts_max=%lld\n", 
1085                pos_min, pos_max,
1086                ts_min, ts_max);
1087 #endif
1088         assert(pos_limit <= pos_max);
1089
1090         if(no_change==0){
1091             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1092             // interpolate position (better than dichotomy)
1093             pos = (int64_t)((double)(pos_max - pos_min) *
1094                             (double)(target_ts - ts_min) /
1095                             (double)(ts_max - ts_min)) + pos_min - approximate_keyframe_distance;
1096         }else if(no_change==1){
1097             // bisection, if interpolation failed to change min or max pos last time
1098             pos = (pos_min + pos_limit)>>1;
1099         }else{
1100             // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1101             pos=pos_min;
1102         }
1103         if(pos <= pos_min)
1104             pos= pos_min + 1;
1105         else if(pos > pos_limit)
1106             pos= pos_limit;
1107         start_pos= pos;
1108
1109         ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1110         if(pos == pos_max)
1111             no_change++;
1112         else
1113             no_change=0;
1114 #ifdef DEBUG_SEEK
1115 av_log(s, AV_LOG_DEBUG, "%Ld %Ld %Ld / %Ld %Ld %Ld target:%Ld limit:%Ld start:%Ld noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1116 #endif
1117         assert(ts != AV_NOPTS_VALUE);
1118         if (target_ts < ts) {
1119             pos_limit = start_pos - 1;
1120             pos_max = pos;
1121             ts_max = ts;
1122         } else {
1123             pos_min = pos;
1124             ts_min = ts;
1125             /* check if we are lucky */
1126             if (target_ts == ts)
1127                 break;
1128         }
1129     }
1130     
1131     pos = pos_min;
1132 #ifdef DEBUG_SEEK
1133     pos_min = pos;
1134     ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1135     pos_min++;
1136     ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1137     av_log(s, AV_LOG_DEBUG, "pos=0x%llx %lld<=%lld<=%lld\n", 
1138            pos, ts_min, target_ts, ts_max);
1139 #endif
1140     /* do the seek */
1141     url_fseek(&s->pb, pos, SEEK_SET);
1142     st->cur_dts = ts_min;
1143
1144     return 0;
1145 }
1146
1147 static int av_seek_frame_generic(AVFormatContext *s, 
1148                                  int stream_index, int64_t timestamp)
1149 {
1150     int index;
1151     AVStream *st;
1152     AVIndexEntry *ie;
1153
1154     if (!s->index_built) {
1155         if (is_raw_stream(s)) {
1156             av_build_index_raw(s);
1157         } else {
1158             return -1;
1159         }
1160         s->index_built = 1;
1161     }
1162
1163     if (stream_index < 0)
1164         stream_index = 0;
1165     st = s->streams[stream_index];
1166     index = av_index_search_timestamp(st, timestamp);
1167     if (index < 0)
1168         return -1;
1169
1170     /* now we have found the index, we can seek */
1171     ie = &st->index_entries[index];
1172     av_read_frame_flush(s);
1173     url_fseek(&s->pb, ie->pos, SEEK_SET);
1174     st->cur_dts = ie->timestamp;
1175     return 0;
1176 }
1177
1178 /**
1179  * Seek to the key frame just before the frame at timestamp
1180  * 'timestamp' in 'stream_index'. If stream_index is (-1), a default
1181  * stream is selected 
1182  */
1183 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp)
1184 {
1185     int ret;
1186     
1187     av_read_frame_flush(s);
1188
1189     /* first, we try the format specific seek */
1190     if (s->iformat->read_seek)
1191         ret = s->iformat->read_seek(s, stream_index, timestamp);
1192     else
1193         ret = -1;
1194     if (ret >= 0) {
1195         return 0;
1196     }
1197
1198     if(s->iformat->read_timestamp)
1199         return av_seek_frame_binary(s, stream_index, timestamp);
1200     else
1201         return av_seek_frame_generic(s, stream_index, timestamp);
1202 }
1203
1204 /*******************************************************/
1205
1206 /* return TRUE if the stream has accurate timings for at least one component */
1207 static int av_has_timings(AVFormatContext *ic)
1208 {
1209     int i;
1210     AVStream *st;
1211
1212     for(i = 0;i < ic->nb_streams; i++) {
1213         st = ic->streams[i];
1214         if (st->start_time != AV_NOPTS_VALUE &&
1215             st->duration != AV_NOPTS_VALUE)
1216             return 1;
1217     }
1218     return 0;
1219 }
1220
1221 /* estimate the stream timings from the one of each components. Also
1222    compute the global bitrate if possible */
1223 static void av_update_stream_timings(AVFormatContext *ic)
1224 {
1225     int64_t start_time, end_time, end_time1;
1226     int i;
1227     AVStream *st;
1228
1229     start_time = MAXINT64;
1230     end_time = MININT64;
1231     for(i = 0;i < ic->nb_streams; i++) {
1232         st = ic->streams[i];
1233         if (st->start_time != AV_NOPTS_VALUE) {
1234             if (st->start_time < start_time)
1235                 start_time = st->start_time;
1236             if (st->duration != AV_NOPTS_VALUE) {
1237                 end_time1 = st->start_time + st->duration;
1238                 if (end_time1 > end_time)
1239                     end_time = end_time1;
1240             }
1241         }
1242     }
1243     if (start_time != MAXINT64) {
1244         ic->start_time = start_time;
1245         if (end_time != MAXINT64) {
1246             ic->duration = end_time - start_time;
1247             if (ic->file_size > 0) {
1248                 /* compute the bit rate */
1249                 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE / 
1250                     (double)ic->duration;
1251             }
1252         }
1253     }
1254
1255 }
1256
1257 static void fill_all_stream_timings(AVFormatContext *ic)
1258 {
1259     int i;
1260     AVStream *st;
1261
1262     av_update_stream_timings(ic);
1263     for(i = 0;i < ic->nb_streams; i++) {
1264         st = ic->streams[i];
1265         if (st->start_time == AV_NOPTS_VALUE) {
1266             st->start_time = ic->start_time;
1267             st->duration = ic->duration;
1268         }
1269     }
1270 }
1271
1272 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1273 {
1274     int64_t filesize, duration;
1275     int bit_rate, i;
1276     AVStream *st;
1277
1278     /* if bit_rate is already set, we believe it */
1279     if (ic->bit_rate == 0) {
1280         bit_rate = 0;
1281         for(i=0;i<ic->nb_streams;i++) {
1282             st = ic->streams[i];
1283             bit_rate += st->codec.bit_rate;
1284         }
1285         ic->bit_rate = bit_rate;
1286     }
1287
1288     /* if duration is already set, we believe it */
1289     if (ic->duration == AV_NOPTS_VALUE && 
1290         ic->bit_rate != 0 && 
1291         ic->file_size != 0)  {
1292         filesize = ic->file_size;
1293         if (filesize > 0) {
1294             duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1295             for(i = 0; i < ic->nb_streams; i++) {
1296                 st = ic->streams[i];
1297                 if (st->start_time == AV_NOPTS_VALUE ||
1298                     st->duration == AV_NOPTS_VALUE) {
1299                     st->start_time = 0;
1300                     st->duration = duration;
1301                 }
1302             }
1303         }
1304     }
1305 }
1306
1307 #define DURATION_MAX_READ_SIZE 250000
1308
1309 /* only usable for MPEG-PS streams */
1310 static void av_estimate_timings_from_pts(AVFormatContext *ic)
1311 {
1312     AVPacket pkt1, *pkt = &pkt1;
1313     AVStream *st;
1314     int read_size, i, ret;
1315     int64_t start_time, end_time, end_time1;
1316     int64_t filesize, offset, duration;
1317     
1318     /* free previous packet */
1319     if (ic->cur_st && ic->cur_st->parser)
1320         av_free_packet(&ic->cur_pkt); 
1321     ic->cur_st = NULL;
1322
1323     /* flush packet queue */
1324     flush_packet_queue(ic);
1325     
1326
1327     /* we read the first packets to get the first PTS (not fully
1328        accurate, but it is enough now) */
1329     url_fseek(&ic->pb, 0, SEEK_SET);
1330     read_size = 0;
1331     for(;;) {
1332         if (read_size >= DURATION_MAX_READ_SIZE)
1333             break;
1334         /* if all info is available, we can stop */
1335         for(i = 0;i < ic->nb_streams; i++) {
1336             st = ic->streams[i];
1337             if (st->start_time == AV_NOPTS_VALUE)
1338                 break;
1339         }
1340         if (i == ic->nb_streams)
1341             break;
1342
1343         ret = av_read_packet(ic, pkt);
1344         if (ret != 0)
1345             break;
1346         read_size += pkt->size;
1347         st = ic->streams[pkt->stream_index];
1348         if (pkt->pts != AV_NOPTS_VALUE) {
1349             if (st->start_time == AV_NOPTS_VALUE)
1350                 st->start_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1351         }
1352         av_free_packet(pkt);
1353     }
1354
1355     /* we compute the minimum start_time and use it as default */
1356     start_time = MAXINT64;
1357     for(i = 0; i < ic->nb_streams; i++) {
1358         st = ic->streams[i];
1359         if (st->start_time != AV_NOPTS_VALUE &&
1360             st->start_time < start_time)
1361             start_time = st->start_time;
1362     }
1363     if (start_time != MAXINT64)
1364         ic->start_time = start_time;
1365     
1366     /* estimate the end time (duration) */
1367     /* XXX: may need to support wrapping */
1368     filesize = ic->file_size;
1369     offset = filesize - DURATION_MAX_READ_SIZE;
1370     if (offset < 0)
1371         offset = 0;
1372
1373     url_fseek(&ic->pb, offset, SEEK_SET);
1374     read_size = 0;
1375     for(;;) {
1376         if (read_size >= DURATION_MAX_READ_SIZE)
1377             break;
1378         /* if all info is available, we can stop */
1379         for(i = 0;i < ic->nb_streams; i++) {
1380             st = ic->streams[i];
1381             if (st->duration == AV_NOPTS_VALUE)
1382                 break;
1383         }
1384         if (i == ic->nb_streams)
1385             break;
1386         
1387         ret = av_read_packet(ic, pkt);
1388         if (ret != 0)
1389             break;
1390         read_size += pkt->size;
1391         st = ic->streams[pkt->stream_index];
1392         if (pkt->pts != AV_NOPTS_VALUE) {
1393             end_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1394             duration = end_time - st->start_time;
1395             if (duration > 0) {
1396                 if (st->duration == AV_NOPTS_VALUE ||
1397                     st->duration < duration)
1398                     st->duration = duration;
1399             }
1400         }
1401         av_free_packet(pkt);
1402     }
1403     
1404     /* estimate total duration */
1405     end_time = MININT64;
1406     for(i = 0;i < ic->nb_streams; i++) {
1407         st = ic->streams[i];
1408         if (st->duration != AV_NOPTS_VALUE) {
1409             end_time1 = st->start_time + st->duration;
1410             if (end_time1 > end_time)
1411                 end_time = end_time1;
1412         }
1413     }
1414     
1415     /* update start_time (new stream may have been created, so we do
1416        it at the end */
1417     if (ic->start_time != AV_NOPTS_VALUE) {
1418         for(i = 0; i < ic->nb_streams; i++) {
1419             st = ic->streams[i];
1420             if (st->start_time == AV_NOPTS_VALUE)
1421                 st->start_time = ic->start_time;
1422         }
1423     }
1424
1425     if (end_time != MININT64) {
1426         /* put dummy values for duration if needed */
1427         for(i = 0;i < ic->nb_streams; i++) {
1428             st = ic->streams[i];
1429             if (st->duration == AV_NOPTS_VALUE && 
1430                 st->start_time != AV_NOPTS_VALUE)
1431                 st->duration = end_time - st->start_time;
1432         }
1433         ic->duration = end_time - ic->start_time;
1434     }
1435
1436     url_fseek(&ic->pb, 0, SEEK_SET);
1437 }
1438
1439 static void av_estimate_timings(AVFormatContext *ic)
1440 {
1441     URLContext *h;
1442     int64_t file_size;
1443
1444     /* get the file size, if possible */
1445     if (ic->iformat->flags & AVFMT_NOFILE) {
1446         file_size = 0;
1447     } else {
1448         h = url_fileno(&ic->pb);
1449         file_size = url_filesize(h);
1450         if (file_size < 0)
1451             file_size = 0;
1452     }
1453     ic->file_size = file_size;
1454
1455     if (ic->iformat == &mpegps_demux) {
1456         /* get accurate estimate from the PTSes */
1457         av_estimate_timings_from_pts(ic);
1458     } else if (av_has_timings(ic)) {
1459         /* at least one components has timings - we use them for all
1460            the components */
1461         fill_all_stream_timings(ic);
1462     } else {
1463         /* less precise: use bit rate info */
1464         av_estimate_timings_from_bit_rate(ic);
1465     }
1466     av_update_stream_timings(ic);
1467
1468 #if 0
1469     {
1470         int i;
1471         AVStream *st;
1472         for(i = 0;i < ic->nb_streams; i++) {
1473             st = ic->streams[i];
1474         printf("%d: start_time: %0.3f duration: %0.3f\n", 
1475                i, (double)st->start_time / AV_TIME_BASE, 
1476                (double)st->duration / AV_TIME_BASE);
1477         }
1478         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n", 
1479                (double)ic->start_time / AV_TIME_BASE, 
1480                (double)ic->duration / AV_TIME_BASE,
1481                ic->bit_rate / 1000);
1482     }
1483 #endif
1484 }
1485
1486 static int has_codec_parameters(AVCodecContext *enc)
1487 {
1488     int val;
1489     switch(enc->codec_type) {
1490     case CODEC_TYPE_AUDIO:
1491         val = enc->sample_rate;
1492         break;
1493     case CODEC_TYPE_VIDEO:
1494         val = enc->width;
1495         break;
1496     default:
1497         val = 1;
1498         break;
1499     }
1500     return (val != 0);
1501 }
1502
1503 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1504 {
1505     int16_t *samples;
1506     AVCodec *codec;
1507     int got_picture, ret;
1508     AVFrame picture;
1509     
1510     codec = avcodec_find_decoder(st->codec.codec_id);
1511     if (!codec)
1512         return -1;
1513     ret = avcodec_open(&st->codec, codec);
1514     if (ret < 0)
1515         return ret;
1516     switch(st->codec.codec_type) {
1517     case CODEC_TYPE_VIDEO:
1518         ret = avcodec_decode_video(&st->codec, &picture, 
1519                                    &got_picture, (uint8_t *)data, size);
1520         break;
1521     case CODEC_TYPE_AUDIO:
1522         samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1523         if (!samples)
1524             goto fail;
1525         ret = avcodec_decode_audio(&st->codec, samples, 
1526                                    &got_picture, (uint8_t *)data, size);
1527         av_free(samples);
1528         break;
1529     default:
1530         break;
1531     }
1532  fail:
1533     avcodec_close(&st->codec);
1534     return ret;
1535 }
1536
1537 /* absolute maximum size we read until we abort */
1538 #define MAX_READ_SIZE        5000000
1539
1540 /* maximum duration until we stop analysing the stream */
1541 #define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 1.0))
1542
1543 /**
1544  * Read the beginning of a media file to get stream information. This
1545  * is useful for file formats with no headers such as MPEG. This
1546  * function also compute the real frame rate in case of mpeg2 repeat
1547  * frame mode.
1548  *
1549  * @param ic media file handle
1550  * @return >=0 if OK. AVERROR_xxx if error.  
1551  */
1552 int av_find_stream_info(AVFormatContext *ic)
1553 {
1554     int i, count, ret, read_size;
1555     AVStream *st;
1556     AVPacket pkt1, *pkt;
1557     AVPacketList *pktl=NULL, **ppktl;
1558
1559     count = 0;
1560     read_size = 0;
1561     ppktl = &ic->packet_buffer;
1562     for(;;) {
1563         /* check if one codec still needs to be handled */
1564         for(i=0;i<ic->nb_streams;i++) {
1565             st = ic->streams[i];
1566             if (!has_codec_parameters(&st->codec))
1567                 break;
1568         }
1569         if (i == ic->nb_streams) {
1570             /* NOTE: if the format has no header, then we need to read
1571                some packets to get most of the streams, so we cannot
1572                stop here */
1573             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1574                 /* if we found the info for all the codecs, we can stop */
1575                 ret = count;
1576                 break;
1577             }
1578         } else {
1579             /* we did not get all the codec info, but we read too much data */
1580             if (read_size >= MAX_READ_SIZE) {
1581                 ret = count;
1582                 break;
1583             }
1584         }
1585
1586         /* NOTE: a new stream can be added there if no header in file
1587            (AVFMTCTX_NOHEADER) */
1588         ret = av_read_frame_internal(ic, &pkt1);
1589         if (ret < 0) {
1590             /* EOF or error */
1591             ret = -1; /* we could not have all the codec parameters before EOF */
1592             if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1593                 i == ic->nb_streams)
1594                 ret = 0;
1595             break;
1596         }
1597
1598         pktl = av_mallocz(sizeof(AVPacketList));
1599         if (!pktl) {
1600             ret = AVERROR_NOMEM;
1601             break;
1602         }
1603
1604         /* add the packet in the buffered packet list */
1605         *ppktl = pktl;
1606         ppktl = &pktl->next;
1607
1608         pkt = &pktl->pkt;
1609         *pkt = pkt1;
1610         
1611         /* duplicate the packet */
1612         if (av_dup_packet(pkt) < 0) {
1613                 ret = AVERROR_NOMEM;
1614                 break;
1615         }
1616
1617         read_size += pkt->size;
1618
1619         st = ic->streams[pkt->stream_index];
1620         st->codec_info_duration += pkt->duration;
1621         if (pkt->duration != 0)
1622             st->codec_info_nb_frames++;
1623
1624         /* if still no information, we try to open the codec and to
1625            decompress the frame. We try to avoid that in most cases as
1626            it takes longer and uses more memory. For MPEG4, we need to
1627            decompress for Quicktime. */
1628         if (!has_codec_parameters(&st->codec) &&
1629             (st->codec.codec_id == CODEC_ID_FLV1 ||
1630              st->codec.codec_id == CODEC_ID_H264 ||
1631              st->codec.codec_id == CODEC_ID_H263 ||
1632              st->codec.codec_id == CODEC_ID_VORBIS ||
1633              (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1634             try_decode_frame(st, pkt->data, pkt->size);
1635         
1636         if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1637             break;
1638         }
1639         count++;
1640     }
1641
1642     /* set real frame rate info */
1643     for(i=0;i<ic->nb_streams;i++) {
1644         st = ic->streams[i];
1645         if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1646             /* compute the real frame rate for telecine */
1647             if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1648                  st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1649                 st->codec.sub_id == 2) {
1650                 if (st->codec_info_nb_frames >= 20) {
1651                     float coded_frame_rate, est_frame_rate;
1652                     est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) / 
1653                         (double)st->codec_info_duration ;
1654                     coded_frame_rate = (double)st->codec.frame_rate /
1655                         (double)st->codec.frame_rate_base;
1656 #if 0
1657                     printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n", 
1658                            coded_frame_rate, est_frame_rate);
1659 #endif
1660                     /* if we detect that it could be a telecine, we
1661                        signal it. It would be better to do it at a
1662                        higher level as it can change in a film */
1663                     if (coded_frame_rate >= 24.97 && 
1664                         (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1665                         st->r_frame_rate = 24024;
1666                         st->r_frame_rate_base = 1001;
1667                     }
1668                 }
1669             }
1670             /* if no real frame rate, use the codec one */
1671             if (!st->r_frame_rate){
1672                 st->r_frame_rate      = st->codec.frame_rate;
1673                 st->r_frame_rate_base = st->codec.frame_rate_base;
1674             }
1675         }
1676     }
1677
1678     av_estimate_timings(ic);
1679     return ret;
1680 }
1681
1682 /*******************************************************/
1683
1684 /**
1685  * start playing a network based stream (e.g. RTSP stream) at the
1686  * current position 
1687  */
1688 int av_read_play(AVFormatContext *s)
1689 {
1690     if (!s->iformat->read_play)
1691         return AVERROR_NOTSUPP;
1692     return s->iformat->read_play(s);
1693 }
1694
1695 /**
1696  * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1697  * to resume it.
1698  */
1699 int av_read_pause(AVFormatContext *s)
1700 {
1701     if (!s->iformat->read_pause)
1702         return AVERROR_NOTSUPP;
1703     return s->iformat->read_pause(s);
1704 }
1705
1706 /**
1707  * Close a media file (but not its codecs)
1708  *
1709  * @param s media file handle
1710  */
1711 void av_close_input_file(AVFormatContext *s)
1712 {
1713     int i, must_open_file;
1714     AVStream *st;
1715
1716     /* free previous packet */
1717     if (s->cur_st && s->cur_st->parser)
1718         av_free_packet(&s->cur_pkt); 
1719
1720     if (s->iformat->read_close)
1721         s->iformat->read_close(s);
1722     for(i=0;i<s->nb_streams;i++) {
1723         /* free all data in a stream component */
1724         st = s->streams[i];
1725         if (st->parser) {
1726             av_parser_close(st->parser);
1727         }
1728         av_free(st->index_entries);
1729         av_free(st);
1730     }
1731     flush_packet_queue(s);
1732     must_open_file = 1;
1733     if (s->iformat->flags & AVFMT_NOFILE) {
1734         must_open_file = 0;
1735     }
1736     if (must_open_file) {
1737         url_fclose(&s->pb);
1738     }
1739     av_freep(&s->priv_data);
1740     av_free(s);
1741 }
1742
1743 /**
1744  * Add a new stream to a media file. Can only be called in the
1745  * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1746  * format context, then new streams can be added in read_packet too.
1747  *
1748  *
1749  * @param s media file handle
1750  * @param id file format dependent stream id 
1751  */
1752 AVStream *av_new_stream(AVFormatContext *s, int id)
1753 {
1754     AVStream *st;
1755
1756     if (s->nb_streams >= MAX_STREAMS)
1757         return NULL;
1758
1759     st = av_mallocz(sizeof(AVStream));
1760     if (!st)
1761         return NULL;
1762     avcodec_get_context_defaults(&st->codec);
1763     if (s->iformat) {
1764         /* no default bitrate if decoding */
1765         st->codec.bit_rate = 0;
1766     }
1767     st->index = s->nb_streams;
1768     st->id = id;
1769     st->start_time = AV_NOPTS_VALUE;
1770     st->duration = AV_NOPTS_VALUE;
1771
1772     /* default pts settings is MPEG like */
1773     av_set_pts_info(st, 33, 1, 90000);
1774     st->last_pkt_pts = AV_NOPTS_VALUE;
1775     st->last_pkt_dts = AV_NOPTS_VALUE;
1776     st->last_pkt_stream_pts = AV_NOPTS_VALUE;
1777     st->last_pkt_stream_dts = AV_NOPTS_VALUE;
1778
1779     s->streams[s->nb_streams++] = st;
1780     return st;
1781 }
1782
1783 /************************************************************/
1784 /* output media file */
1785
1786 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1787 {
1788     int ret;
1789     
1790     if (s->oformat->priv_data_size > 0) {
1791         s->priv_data = av_mallocz(s->oformat->priv_data_size);
1792         if (!s->priv_data)
1793             return AVERROR_NOMEM;
1794     } else
1795         s->priv_data = NULL;
1796         
1797     if (s->oformat->set_parameters) {
1798         ret = s->oformat->set_parameters(s, ap);
1799         if (ret < 0)
1800             return ret;
1801     }
1802     return 0;
1803 }
1804
1805 /**
1806  * allocate the stream private data and write the stream header to an
1807  * output media file
1808  *
1809  * @param s media file handle
1810  * @return 0 if OK. AVERROR_xxx if error.  
1811  */
1812 int av_write_header(AVFormatContext *s)
1813 {
1814     int ret, i;
1815     AVStream *st;
1816
1817     ret = s->oformat->write_header(s);
1818     if (ret < 0)
1819         return ret;
1820
1821     /* init PTS generation */
1822     for(i=0;i<s->nb_streams;i++) {
1823         st = s->streams[i];
1824
1825         switch (st->codec.codec_type) {
1826         case CODEC_TYPE_AUDIO:
1827             av_frac_init(&st->pts, 0, 0, 
1828                          (int64_t)st->time_base.num * st->codec.sample_rate);
1829             break;
1830         case CODEC_TYPE_VIDEO:
1831             av_frac_init(&st->pts, 0, 0, 
1832                          (int64_t)st->time_base.num * st->codec.frame_rate);
1833             break;
1834         default:
1835             break;
1836         }
1837     }
1838     return 0;
1839 }
1840
1841 /**
1842  * Write a packet to an output media file. The packet shall contain
1843  * one audio or video frame.
1844  *
1845  * @param s media file handle
1846  * @param stream_index stream index
1847  * @param buf buffer containing the frame data
1848  * @param size size of buffer
1849  * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
1850  */
1851 int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf, 
1852                    int size)
1853 {
1854     AVStream *st;
1855     int64_t pts_mask;
1856     int ret, frame_size;
1857
1858     st = s->streams[stream_index];
1859     pts_mask = (1LL << st->pts_wrap_bits) - 1;
1860
1861     /* HACK/FIXME we skip all zero size audio packets so a encoder can pass pts by outputing zero size packets */
1862     if(st->codec.codec_type==CODEC_TYPE_AUDIO && size==0)
1863         ret = 0;
1864     else
1865         ret = s->oformat->write_packet(s, stream_index, buf, size, 
1866                                        st->pts.val & pts_mask);
1867     
1868     if (ret < 0)
1869         return ret;
1870
1871     /* update pts */
1872     switch (st->codec.codec_type) {
1873     case CODEC_TYPE_AUDIO:
1874         frame_size = get_audio_frame_size(&st->codec, size);
1875
1876         /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
1877            but it would be better if we had the real timestamps from the encoder */
1878         if (frame_size >= 0 && (size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
1879             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
1880         }
1881         break;
1882     case CODEC_TYPE_VIDEO:
1883         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec.frame_rate_base);
1884         break;
1885     default:
1886         break;
1887     }
1888     return ret;
1889 }
1890
1891 /**
1892  * write the stream trailer to an output media file and and free the
1893  * file private data.
1894  *
1895  * @param s media file handle
1896  * @return 0 if OK. AVERROR_xxx if error.  */
1897 int av_write_trailer(AVFormatContext *s)
1898 {
1899     int ret;
1900     ret = s->oformat->write_trailer(s);
1901     av_freep(&s->priv_data);
1902     return ret;
1903 }
1904
1905 /* "user interface" functions */
1906
1907 void dump_format(AVFormatContext *ic,
1908                  int index, 
1909                  const char *url,
1910                  int is_output)
1911 {
1912     int i, flags;
1913     char buf[256];
1914
1915     av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n", 
1916             is_output ? "Output" : "Input",
1917             index, 
1918             is_output ? ic->oformat->name : ic->iformat->name, 
1919             is_output ? "to" : "from", url);
1920     if (!is_output) {
1921         av_log(NULL, AV_LOG_DEBUG, "  Duration: ");
1922         if (ic->duration != AV_NOPTS_VALUE) {
1923             int hours, mins, secs, us;
1924             secs = ic->duration / AV_TIME_BASE;
1925             us = ic->duration % AV_TIME_BASE;
1926             mins = secs / 60;
1927             secs %= 60;
1928             hours = mins / 60;
1929             mins %= 60;
1930             av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs, 
1931                    (10 * us) / AV_TIME_BASE);
1932         } else {
1933             av_log(NULL, AV_LOG_DEBUG, "N/A");
1934         }
1935         av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
1936         if (ic->bit_rate) {
1937             av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
1938         } else {
1939             av_log(NULL, AV_LOG_DEBUG, "N/A");
1940         }
1941         av_log(NULL, AV_LOG_DEBUG, "\n");
1942     }
1943     for(i=0;i<ic->nb_streams;i++) {
1944         AVStream *st = ic->streams[i];
1945         avcodec_string(buf, sizeof(buf), &st->codec, is_output);
1946         av_log(NULL, AV_LOG_DEBUG, "  Stream #%d.%d", index, i);
1947         /* the pid is an important information, so we display it */
1948         /* XXX: add a generic system */
1949         if (is_output)
1950             flags = ic->oformat->flags;
1951         else
1952             flags = ic->iformat->flags;
1953         if (flags & AVFMT_SHOW_IDS) {
1954             av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
1955         }
1956         av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
1957     }
1958 }
1959
1960 typedef struct {
1961     const char *abv;
1962     int width, height;
1963     int frame_rate, frame_rate_base;
1964 } AbvEntry;
1965
1966 static AbvEntry frame_abvs[] = {
1967     { "ntsc",      720, 480, 30000, 1001 },
1968     { "pal",       720, 576,    25,    1 },
1969     { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
1970     { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
1971     { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
1972     { "spal",      768, 576,    25,    1 }, /* square pixel pal */
1973     { "film",      352, 240,    24,    1 },
1974     { "ntsc-film", 352, 240, 24000, 1001 },
1975     { "sqcif",     128,  96,     0,    0 },
1976     { "qcif",      176, 144,     0,    0 },
1977     { "cif",       352, 288,     0,    0 },
1978     { "4cif",      704, 576,     0,    0 },
1979 };
1980
1981 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
1982 {
1983     int i;
1984     int n = sizeof(frame_abvs) / sizeof(AbvEntry);
1985     const char *p;
1986     int frame_width = 0, frame_height = 0;
1987
1988     for(i=0;i<n;i++) {
1989         if (!strcmp(frame_abvs[i].abv, str)) {
1990             frame_width = frame_abvs[i].width;
1991             frame_height = frame_abvs[i].height;
1992             break;
1993         }
1994     }
1995     if (i == n) {
1996         p = str;
1997         frame_width = strtol(p, (char **)&p, 10);
1998         if (*p)
1999             p++;
2000         frame_height = strtol(p, (char **)&p, 10);
2001     }
2002     if (frame_width <= 0 || frame_height <= 0)
2003         return -1;
2004     *width_ptr = frame_width;
2005     *height_ptr = frame_height;
2006     return 0;
2007 }
2008
2009 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2010 {
2011     int i;
2012     char* cp;
2013    
2014     /* First, we check our abbreviation table */
2015     for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2016          if (!strcmp(frame_abvs[i].abv, arg)) {
2017              *frame_rate = frame_abvs[i].frame_rate;
2018              *frame_rate_base = frame_abvs[i].frame_rate_base;
2019              return 0;
2020          }
2021
2022     /* Then, we try to parse it as fraction */
2023     cp = strchr(arg, '/');
2024     if (cp) {
2025         char* cpp;
2026         *frame_rate = strtol(arg, &cpp, 10);
2027         if (cpp != arg || cpp == cp) 
2028             *frame_rate_base = strtol(cp+1, &cpp, 10);
2029         else
2030            *frame_rate = 0;
2031     } 
2032     else {
2033         /* Finally we give up and parse it as double */
2034         *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
2035         *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
2036     }
2037     if (!*frame_rate || !*frame_rate_base)
2038         return -1;
2039     else
2040         return 0;
2041 }
2042
2043 /* Syntax:
2044  * - If not a duration:
2045  *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2046  * Time is localtime unless Z is suffixed to the end. In this case GMT
2047  * Return the date in micro seconds since 1970 
2048  * - If duration:
2049  *  HH[:MM[:SS[.m...]]]
2050  *  S+[.m...]
2051  */
2052 int64_t parse_date(const char *datestr, int duration)
2053 {
2054     const char *p;
2055     int64_t t;
2056     struct tm dt;
2057     int i;
2058     static const char *date_fmt[] = {
2059         "%Y-%m-%d",
2060         "%Y%m%d",
2061     };
2062     static const char *time_fmt[] = {
2063         "%H:%M:%S",
2064         "%H%M%S",
2065     };
2066     const char *q;
2067     int is_utc, len;
2068     char lastch;
2069
2070 #undef time
2071     time_t now = time(0);
2072
2073     len = strlen(datestr);
2074     if (len > 0)
2075         lastch = datestr[len - 1];
2076     else
2077         lastch = '\0';
2078     is_utc = (lastch == 'z' || lastch == 'Z');
2079
2080     memset(&dt, 0, sizeof(dt));
2081
2082     p = datestr;
2083     q = NULL;
2084     if (!duration) {
2085         for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2086             q = small_strptime(p, date_fmt[i], &dt);
2087             if (q) {
2088                 break;
2089             }
2090         }
2091
2092         if (!q) {
2093             if (is_utc) {
2094                 dt = *gmtime(&now);
2095             } else {
2096                 dt = *localtime(&now);
2097             }
2098             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2099         } else {
2100             p = q;
2101         }
2102
2103         if (*p == 'T' || *p == 't' || *p == ' ')
2104             p++;
2105
2106         for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2107             q = small_strptime(p, time_fmt[i], &dt);
2108             if (q) {
2109                 break;
2110             }
2111         }
2112     } else {
2113         q = small_strptime(p, time_fmt[0], &dt);
2114         if (!q) {
2115             dt.tm_sec = strtol(p, (char **)&q, 10);
2116             dt.tm_min = 0;
2117             dt.tm_hour = 0;
2118         }
2119     }
2120
2121     /* Now we have all the fields that we can get */
2122     if (!q) {
2123         if (duration)
2124             return 0;
2125         else
2126             return now * int64_t_C(1000000);
2127     }
2128
2129     if (duration) {
2130         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2131     } else {
2132         dt.tm_isdst = -1;       /* unknown */
2133         if (is_utc) {
2134             t = mktimegm(&dt);
2135         } else {
2136             t = mktime(&dt);
2137         }
2138     }
2139
2140     t *= 1000000;
2141
2142     if (*q == '.') {
2143         int val, n;
2144         q++;
2145         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2146             if (!isdigit(*q)) 
2147                 break;
2148             val += n * (*q - '0');
2149         }
2150         t += val;
2151     }
2152     return t;
2153 }
2154
2155 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
2156    1 if found */
2157 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2158 {
2159     const char *p;
2160     char tag[128], *q;
2161
2162     p = info;
2163     if (*p == '?')
2164         p++;
2165     for(;;) {
2166         q = tag;
2167         while (*p != '\0' && *p != '=' && *p != '&') {
2168             if ((q - tag) < sizeof(tag) - 1)
2169                 *q++ = *p;
2170             p++;
2171         }
2172         *q = '\0';
2173         q = arg;
2174         if (*p == '=') {
2175             p++;
2176             while (*p != '&' && *p != '\0') {
2177                 if ((q - arg) < arg_size - 1) {
2178                     if (*p == '+')
2179                         *q++ = ' ';
2180                     else
2181                         *q++ = *p;
2182                 }
2183                 p++;
2184             }
2185             *q = '\0';
2186         }
2187         if (!strcmp(tag, tag1)) 
2188             return 1;
2189         if (*p != '&')
2190             break;
2191         p++;
2192     }
2193     return 0;
2194 }
2195
2196 /* Return in 'buf' the path with '%d' replaced by number. Also handles
2197    the '%0nd' format where 'n' is the total number of digits and
2198    '%%'. Return 0 if OK, and -1 if format error */
2199 int get_frame_filename(char *buf, int buf_size,
2200                        const char *path, int number)
2201 {
2202     const char *p;
2203     char *q, buf1[20], c;
2204     int nd, len, percentd_found;
2205
2206     q = buf;
2207     p = path;
2208     percentd_found = 0;
2209     for(;;) {
2210         c = *p++;
2211         if (c == '\0')
2212             break;
2213         if (c == '%') {
2214             do {
2215                 nd = 0;
2216                 while (isdigit(*p)) {
2217                     nd = nd * 10 + *p++ - '0';
2218                 }
2219                 c = *p++;
2220             } while (isdigit(c));
2221
2222             switch(c) {
2223             case '%':
2224                 goto addchar;
2225             case 'd':
2226                 if (percentd_found)
2227                     goto fail;
2228                 percentd_found = 1;
2229                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2230                 len = strlen(buf1);
2231                 if ((q - buf + len) > buf_size - 1)
2232                     goto fail;
2233                 memcpy(q, buf1, len);
2234                 q += len;
2235                 break;
2236             default:
2237                 goto fail;
2238             }
2239         } else {
2240         addchar:
2241             if ((q - buf) < buf_size - 1)
2242                 *q++ = c;
2243         }
2244     }
2245     if (!percentd_found)
2246         goto fail;
2247     *q = '\0';
2248     return 0;
2249  fail:
2250     *q = '\0';
2251     return -1;
2252 }
2253
2254 /**
2255  * Print  nice hexa dump of a buffer
2256  * @param f stream for output
2257  * @param buf buffer
2258  * @param size buffer size
2259  */
2260 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2261 {
2262     int len, i, j, c;
2263
2264     for(i=0;i<size;i+=16) {
2265         len = size - i;
2266         if (len > 16)
2267             len = 16;
2268         fprintf(f, "%08x ", i);
2269         for(j=0;j<16;j++) {
2270             if (j < len)
2271                 fprintf(f, " %02x", buf[i+j]);
2272             else
2273                 fprintf(f, "   ");
2274         }
2275         fprintf(f, " ");
2276         for(j=0;j<len;j++) {
2277             c = buf[i+j];
2278             if (c < ' ' || c > '~')
2279                 c = '.';
2280             fprintf(f, "%c", c);
2281         }
2282         fprintf(f, "\n");
2283     }
2284 }
2285
2286 /**
2287  * Print on 'f' a nice dump of a packet
2288  * @param f stream for output
2289  * @param pkt packet to dump
2290  * @param dump_payload true if the payload must be displayed too
2291  */
2292 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2293 {
2294     fprintf(f, "stream #%d:\n", pkt->stream_index);
2295     fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2296     fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2297     /* DTS is _always_ valid after av_read_frame() */
2298     fprintf(f, "  dts=");
2299     if (pkt->dts == AV_NOPTS_VALUE)
2300         fprintf(f, "N/A");
2301     else
2302         fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2303     /* PTS may be not known if B frames are present */
2304     fprintf(f, "  pts=");
2305     if (pkt->pts == AV_NOPTS_VALUE)
2306         fprintf(f, "N/A");
2307     else
2308         fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2309     fprintf(f, "\n");
2310     fprintf(f, "  size=%d\n", pkt->size);
2311     if (dump_payload)
2312         av_hex_dump(f, pkt->data, pkt->size);
2313 }
2314
2315 void url_split(char *proto, int proto_size,
2316                char *hostname, int hostname_size,
2317                int *port_ptr,
2318                char *path, int path_size,
2319                const char *url)
2320 {
2321     const char *p;
2322     char *q;
2323     int port;
2324
2325     port = -1;
2326
2327     p = url;
2328     q = proto;
2329     while (*p != ':' && *p != '\0') {
2330         if ((q - proto) < proto_size - 1)
2331             *q++ = *p;
2332         p++;
2333     }
2334     if (proto_size > 0)
2335         *q = '\0';
2336     if (*p == '\0') {
2337         if (proto_size > 0)
2338             proto[0] = '\0';
2339         if (hostname_size > 0)
2340             hostname[0] = '\0';
2341         p = url;
2342     } else {
2343         p++;
2344         if (*p == '/')
2345             p++;
2346         if (*p == '/')
2347             p++;
2348         q = hostname;
2349         while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
2350             if ((q - hostname) < hostname_size - 1)
2351                 *q++ = *p;
2352             p++;
2353         }
2354         if (hostname_size > 0)
2355             *q = '\0';
2356         if (*p == ':') {
2357             p++;
2358             port = strtoul(p, (char **)&p, 10);
2359         }
2360     }
2361     if (port_ptr)
2362         *port_ptr = port;
2363     pstrcpy(path, path_size, p);
2364 }
2365
2366 /**
2367  * Set the pts for a given stream
2368  * @param s stream 
2369  * @param pts_wrap_bits number of bits effectively used by the pts
2370  *        (used for wrap control, 33 is the value for MPEG) 
2371  * @param pts_num numerator to convert to seconds (MPEG: 1) 
2372  * @param pts_den denominator to convert to seconds (MPEG: 90000)
2373  */
2374 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2375                      int pts_num, int pts_den)
2376 {
2377     s->pts_wrap_bits = pts_wrap_bits;
2378     s->time_base.num = pts_num;
2379     s->time_base.den = pts_den;
2380 }
2381
2382 /* fraction handling */
2383
2384 /**
2385  * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2386  * as 0 <= num < den.
2387  *
2388  * @param f fractional number
2389  * @param val integer value
2390  * @param num must be >= 0
2391  * @param den must be >= 1 
2392  */
2393 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2394 {
2395     num += (den >> 1);
2396     if (num >= den) {
2397         val += num / den;
2398         num = num % den;
2399     }
2400     f->val = val;
2401     f->num = num;
2402     f->den = den;
2403 }
2404
2405 /* set f to (val + 0.5) */
2406 void av_frac_set(AVFrac *f, int64_t val)
2407 {
2408     f->val = val;
2409     f->num = f->den >> 1;
2410 }
2411
2412 /**
2413  * Fractionnal addition to f: f = f + (incr / f->den)
2414  *
2415  * @param f fractional number
2416  * @param incr increment, can be positive or negative
2417  */
2418 void av_frac_add(AVFrac *f, int64_t incr)
2419 {
2420     int64_t num, den;
2421
2422     num = f->num + incr;
2423     den = f->den;
2424     if (num < 0) {
2425         f->val += num / den;
2426         num = num % den;
2427         if (num < 0) {
2428             num += den;
2429             f->val--;
2430         }
2431     } else if (num >= den) {
2432         f->val += num / den;
2433         num = num % den;
2434     }
2435     f->num = num;
2436 }
2437
2438 /**
2439  * register a new image format
2440  * @param img_fmt Image format descriptor
2441  */
2442 void av_register_image_format(AVImageFormat *img_fmt)
2443 {
2444     AVImageFormat **p;
2445
2446     p = &first_image_format;
2447     while (*p != NULL) p = &(*p)->next;
2448     *p = img_fmt;
2449     img_fmt->next = NULL;
2450 }
2451
2452 /* guess image format */
2453 AVImageFormat *av_probe_image_format(AVProbeData *pd)
2454 {
2455     AVImageFormat *fmt1, *fmt;
2456     int score, score_max;
2457
2458     fmt = NULL;
2459     score_max = 0;
2460     for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2461         if (fmt1->img_probe) {
2462             score = fmt1->img_probe(pd);
2463             if (score > score_max) {
2464                 score_max = score;
2465                 fmt = fmt1;
2466             }
2467         }
2468     }
2469     return fmt;
2470 }
2471
2472 AVImageFormat *guess_image_format(const char *filename)
2473 {
2474     AVImageFormat *fmt1;
2475
2476     for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2477         if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2478             return fmt1;
2479     }
2480     return NULL;
2481 }
2482
2483 /**
2484  * Read an image from a stream. 
2485  * @param gb byte stream containing the image
2486  * @param fmt image format, NULL if probing is required
2487  */
2488 int av_read_image(ByteIOContext *pb, const char *filename,
2489                   AVImageFormat *fmt,
2490                   int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2491 {
2492     char buf[PROBE_BUF_SIZE];
2493     AVProbeData probe_data, *pd = &probe_data;
2494     offset_t pos;
2495     int ret;
2496
2497     if (!fmt) {
2498         pd->filename = filename;
2499         pd->buf = buf;
2500         pos = url_ftell(pb);
2501         pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2502         url_fseek(pb, pos, SEEK_SET);
2503         fmt = av_probe_image_format(pd);
2504     }
2505     if (!fmt)
2506         return AVERROR_NOFMT;
2507     ret = fmt->img_read(pb, alloc_cb, opaque);
2508     return ret;
2509 }
2510
2511 /**
2512  * Write an image to a stream.
2513  * @param pb byte stream for the image output
2514  * @param fmt image format
2515  * @param img image data and informations
2516  */
2517 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2518 {
2519     return fmt->img_write(pb, img);
2520 }
2521