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