default stream timebase docs patch by (Nathan Kurz <nate at verse dot com>)
[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 = NULL;
25 AVOutputFormat *first_oformat = NULL;
26 AVImageFormat *first_image_format = NULL;
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 /* get data from the fifo (return -1 if not enough data) */
268 int put_fifo(ByteIOContext *pb, FifoBuffer *f, int buf_size, uint8_t **rptr_ptr)
269 {
270     uint8_t *rptr = *rptr_ptr;
271     int size, len;
272
273     if (f->wptr >= rptr) {
274         size = f->wptr - rptr;
275     } else {
276         size = (f->end - rptr) + (f->wptr - f->buffer);
277     }
278     
279     if (size < buf_size)
280         return -1;
281     while (buf_size > 0) {
282         len = f->end - rptr;
283         if (len > buf_size)
284             len = buf_size;
285         put_buffer(pb, rptr, len);
286         rptr += len;
287         if (rptr >= f->end)
288             rptr = f->buffer;
289         buf_size -= len;
290     }
291     *rptr_ptr = rptr;
292     return 0;
293 }
294
295 int filename_number_test(const char *filename)
296 {
297     char buf[1024];
298     if(!filename)
299         return -1;
300     return get_frame_filename(buf, sizeof(buf), filename, 1);
301 }
302
303 /* guess file format */
304 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
305 {
306     AVInputFormat *fmt1, *fmt;
307     int score, score_max;
308
309     fmt = NULL;
310     score_max = 0;
311     for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
312         if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
313             continue;
314         score = 0;
315         if (fmt1->read_probe) {
316             score = fmt1->read_probe(pd);
317         } else if (fmt1->extensions) {
318             if (match_ext(pd->filename, fmt1->extensions)) {
319                 score = 50;
320             }
321         } 
322         if (score > score_max) {
323             score_max = score;
324             fmt = fmt1;
325         }
326     }
327     return fmt;
328 }
329
330 /************************************************************/
331 /* input media file */
332
333 /**
334  * open a media file from an IO stream. 'fmt' must be specified.
335  */
336
337 static const char* format_to_name(void* ptr)
338 {
339     AVFormatContext* fc = (AVFormatContext*) ptr;
340     if(fc->iformat) return fc->iformat->name;
341     else if(fc->oformat) return fc->oformat->name;
342     else return "NULL";
343 }
344
345 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
346
347 AVFormatContext *av_alloc_format_context(void)
348 {
349     AVFormatContext *ic;
350     ic = av_mallocz(sizeof(AVFormatContext));
351     if (!ic) return ic;
352     ic->av_class = &av_format_context_class;
353     return ic;
354 }
355
356 int av_open_input_stream(AVFormatContext **ic_ptr, 
357                          ByteIOContext *pb, const char *filename, 
358                          AVInputFormat *fmt, AVFormatParameters *ap)
359 {
360     int err;
361     AVFormatContext *ic;
362
363     ic = av_alloc_format_context();
364     if (!ic) {
365         err = AVERROR_NOMEM;
366         goto fail;
367     }
368     ic->iformat = fmt;
369     if (pb)
370         ic->pb = *pb;
371     ic->duration = AV_NOPTS_VALUE;
372     ic->start_time = AV_NOPTS_VALUE;
373     pstrcpy(ic->filename, sizeof(ic->filename), filename);
374
375     /* allocate private data */
376     if (fmt->priv_data_size > 0) {
377         ic->priv_data = av_mallocz(fmt->priv_data_size);
378         if (!ic->priv_data) {
379             err = AVERROR_NOMEM;
380             goto fail;
381         }
382     } else {
383         ic->priv_data = NULL;
384     }
385
386     err = ic->iformat->read_header(ic, ap);
387     if (err < 0)
388         goto fail;
389
390     if (pb)
391         ic->data_offset = url_ftell(&ic->pb);
392
393     *ic_ptr = ic;
394     return 0;
395  fail:
396     if (ic) {
397         av_freep(&ic->priv_data);
398     }
399     av_free(ic);
400     *ic_ptr = NULL;
401     return err;
402 }
403
404 #define PROBE_BUF_SIZE 2048
405
406 /**
407  * Open a media file as input. The codec are not opened. Only the file
408  * header (if present) is read.
409  *
410  * @param ic_ptr the opened media file handle is put here
411  * @param filename filename to open.
412  * @param fmt if non NULL, force the file format to use
413  * @param buf_size optional buffer size (zero if default is OK)
414  * @param ap additionnal parameters needed when opening the file (NULL if default)
415  * @return 0 if OK. AVERROR_xxx otherwise.
416  */
417 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename, 
418                        AVInputFormat *fmt,
419                        int buf_size,
420                        AVFormatParameters *ap)
421 {
422     int err, must_open_file, file_opened;
423     uint8_t buf[PROBE_BUF_SIZE];
424     AVProbeData probe_data, *pd = &probe_data;
425     ByteIOContext pb1, *pb = &pb1;
426     
427     file_opened = 0;
428     pd->filename = "";
429     if (filename)
430         pd->filename = filename;
431     pd->buf = buf;
432     pd->buf_size = 0;
433
434     if (!fmt) {
435         /* guess format if no file can be opened  */
436         fmt = av_probe_input_format(pd, 0);
437     }
438
439     /* do not open file if the format does not need it. XXX: specific
440        hack needed to handle RTSP/TCP */
441     must_open_file = 1;
442     if (fmt && (fmt->flags & AVFMT_NOFILE)) {
443         must_open_file = 0;
444         pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise its uninitalized
445     }
446
447     if (!fmt || must_open_file) {
448         /* if no file needed do not try to open one */
449         if (url_fopen(pb, filename, URL_RDONLY) < 0) {
450             err = AVERROR_IO;
451             goto fail;
452         }
453         file_opened = 1;
454         if (buf_size > 0) {
455             url_setbufsize(pb, buf_size);
456         }
457         if (!fmt) {
458             /* read probe data */
459             pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
460             if (url_fseek(pb, 0, SEEK_SET) == (offset_t)-EPIPE) {
461                 url_fclose(pb);
462                 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
463                     err = AVERROR_IO;
464                     goto fail;
465                 }
466             }
467         }
468     }
469     
470     /* guess file format */
471     if (!fmt) {
472         fmt = av_probe_input_format(pd, 1);
473     }
474
475     /* if still no format found, error */
476     if (!fmt) {
477         err = AVERROR_NOFMT;
478         goto fail;
479     }
480         
481     /* XXX: suppress this hack for redirectors */
482 #ifdef CONFIG_NETWORK
483     if (fmt == &redir_demux) {
484         err = redir_open(ic_ptr, pb);
485         url_fclose(pb);
486         return err;
487     }
488 #endif
489
490     /* check filename in case of an image number is expected */
491     if (fmt->flags & AVFMT_NEEDNUMBER) {
492         if (filename_number_test(filename) < 0) { 
493             err = AVERROR_NUMEXPECTED;
494             goto fail;
495         }
496     }
497     err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
498     if (err)
499         goto fail;
500     return 0;
501  fail:
502     if (file_opened)
503         url_fclose(pb);
504     *ic_ptr = NULL;
505     return err;
506     
507 }
508
509 /*******************************************************/
510
511 /**
512  * Read a transport packet from a media file. This function is
513  * absolete and should never be used. Use av_read_frame() instead.
514  * 
515  * @param s media file handle
516  * @param pkt is filled 
517  * @return 0 if OK. AVERROR_xxx if error.  
518  */
519 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
520 {
521     return s->iformat->read_packet(s, pkt);
522 }
523
524 /**********************************************************/
525
526 /* get the number of samples of an audio frame. Return (-1) if error */
527 static int get_audio_frame_size(AVCodecContext *enc, int size)
528 {
529     int frame_size;
530
531     if (enc->frame_size <= 1) {
532         /* specific hack for pcm codecs because no frame size is
533            provided */
534         switch(enc->codec_id) {
535         case CODEC_ID_PCM_S16LE:
536         case CODEC_ID_PCM_S16BE:
537         case CODEC_ID_PCM_U16LE:
538         case CODEC_ID_PCM_U16BE:
539             if (enc->channels == 0)
540                 return -1;
541             frame_size = size / (2 * enc->channels);
542             break;
543         case CODEC_ID_PCM_S8:
544         case CODEC_ID_PCM_U8:
545         case CODEC_ID_PCM_MULAW:
546         case CODEC_ID_PCM_ALAW:
547             if (enc->channels == 0)
548                 return -1;
549             frame_size = size / (enc->channels);
550             break;
551         default:
552             /* used for example by ADPCM codecs */
553             if (enc->bit_rate == 0)
554                 return -1;
555             frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
556             break;
557         }
558     } else {
559         frame_size = enc->frame_size;
560     }
561     return frame_size;
562 }
563
564
565 /* return the frame duration in seconds, return 0 if not available */
566 static void compute_frame_duration(int *pnum, int *pden, AVStream *st, 
567                                    AVCodecParserContext *pc, AVPacket *pkt)
568 {
569     int frame_size;
570
571     *pnum = 0;
572     *pden = 0;
573     switch(st->codec.codec_type) {
574     case CODEC_TYPE_VIDEO:
575         *pnum = st->codec.frame_rate_base;
576         *pden = st->codec.frame_rate;
577         if (pc && pc->repeat_pict) {
578             *pden *= 2;
579             *pnum = (*pnum) * (2 + pc->repeat_pict);
580         }
581         break;
582     case CODEC_TYPE_AUDIO:
583         frame_size = get_audio_frame_size(&st->codec, pkt->size);
584         if (frame_size < 0)
585             break;
586         *pnum = frame_size;
587         *pden = st->codec.sample_rate;
588         break;
589     default:
590         break;
591     }
592 }
593
594 static int64_t lsb2full(int64_t lsb, int64_t last_ts, int lsb_bits){
595     int64_t mask = lsb_bits < 64 ? (1LL<<lsb_bits)-1 : -1LL;
596     int64_t delta= last_ts - mask/2;
597     return  ((lsb - delta)&mask) + delta;
598 }
599
600 static void compute_pkt_fields(AVFormatContext *s, AVStream *st, 
601                                AVCodecParserContext *pc, AVPacket *pkt)
602 {
603     int num, den, presentation_delayed;
604
605     /* handle wrapping */
606     if(st->cur_dts != AV_NOPTS_VALUE){
607         if(pkt->pts != AV_NOPTS_VALUE)
608             pkt->pts= lsb2full(pkt->pts, st->cur_dts, st->pts_wrap_bits);
609         if(pkt->dts != AV_NOPTS_VALUE)
610             pkt->dts= lsb2full(pkt->dts, st->cur_dts, st->pts_wrap_bits);
611     }
612     
613     if (pkt->duration == 0) {
614         compute_frame_duration(&num, &den, st, pc, pkt);
615         if (den && num) {
616             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
617         }
618     }
619
620     /* do we have a video B frame ? */
621     presentation_delayed = 0;
622     if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
623         /* XXX: need has_b_frame, but cannot get it if the codec is
624            not initialized */
625         if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
626              st->codec.codec_id == CODEC_ID_MPEG2VIDEO ||
627              st->codec.codec_id == CODEC_ID_MPEG4 ||
628              st->codec.codec_id == CODEC_ID_H264) && 
629             pc && pc->pict_type != FF_B_TYPE)
630             presentation_delayed = 1;
631         /* this may be redundant, but it shouldnt hurt */
632         if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
633             presentation_delayed = 1;
634     }
635     
636     if(st->cur_dts == AV_NOPTS_VALUE){
637         if(presentation_delayed) st->cur_dts = -pkt->duration;
638         else                     st->cur_dts = 0;
639     }
640
641 //    av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%lld, dts:%lld cur_dts:%lld st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
642     /* interpolate PTS and DTS if they are not present */
643     if (presentation_delayed) {
644         /* DTS = decompression time stamp */
645         /* PTS = presentation time stamp */
646         if (pkt->dts == AV_NOPTS_VALUE) {
647             /* if we know the last pts, use it */
648             if(st->last_IP_pts != AV_NOPTS_VALUE)
649                 st->cur_dts = pkt->dts = st->last_IP_pts;
650             else
651                 pkt->dts = st->cur_dts;
652         } else {
653             st->cur_dts = pkt->dts;
654         }
655         /* this is tricky: the dts must be incremented by the duration
656            of the frame we are displaying, i.e. the last I or P frame */
657         if (st->last_IP_duration == 0)
658             st->cur_dts += pkt->duration;
659         else
660             st->cur_dts += st->last_IP_duration;
661         st->last_IP_duration  = pkt->duration;
662         st->last_IP_pts= pkt->pts;
663         /* cannot compute PTS if not present (we can compute it only
664            by knowing the futur */
665     } else {
666         /* presentation is not delayed : PTS and DTS are the same */
667         if (pkt->pts == AV_NOPTS_VALUE) {
668             if (pkt->dts == AV_NOPTS_VALUE) {
669                 pkt->pts = st->cur_dts;
670                 pkt->dts = st->cur_dts;
671             }
672             else {
673                 st->cur_dts = pkt->dts;
674                 pkt->pts = pkt->dts;
675             }
676         } else {
677             st->cur_dts = pkt->pts;
678             pkt->dts = pkt->pts;
679         }
680         st->cur_dts += pkt->duration;
681     }
682 //    av_log(NULL, AV_LOG_DEBUG, "OUTdelayed:%d pts:%lld, dts:%lld cur_dts:%lld\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts);
683     
684     /* update flags */
685     if (pc) {
686         pkt->flags = 0;
687         /* key frame computation */
688         switch(st->codec.codec_type) {
689         case CODEC_TYPE_VIDEO:
690             if (pc->pict_type == FF_I_TYPE)
691                 pkt->flags |= PKT_FLAG_KEY;
692             break;
693         case CODEC_TYPE_AUDIO:
694             pkt->flags |= PKT_FLAG_KEY;
695             break;
696         default:
697             break;
698         }
699     }
700
701     /* convert the packet time stamp units */
702     if(pkt->pts != AV_NOPTS_VALUE)
703         pkt->pts = av_rescale(pkt->pts, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
704     if(pkt->dts != AV_NOPTS_VALUE)
705         pkt->dts = av_rescale(pkt->dts, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
706
707     /* duration field */
708     pkt->duration = av_rescale(pkt->duration, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);
709 }
710
711 void av_destruct_packet_nofree(AVPacket *pkt)
712 {
713     pkt->data = NULL; pkt->size = 0;
714 }
715
716 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
717 {
718     AVStream *st;
719     int len, ret, i;
720
721     for(;;) {
722         /* select current input stream component */
723         st = s->cur_st;
724         if (st) {
725             if (!st->parser) {
726                 /* no parsing needed: we just output the packet as is */
727                 /* raw data support */
728                 *pkt = s->cur_pkt;
729                 compute_pkt_fields(s, st, NULL, pkt);
730                 s->cur_st = NULL;
731                 return 0;
732             } else if (s->cur_len > 0) {
733                 len = av_parser_parse(st->parser, &st->codec, &pkt->data, &pkt->size, 
734                                       s->cur_ptr, s->cur_len,
735                                       s->cur_pkt.pts, s->cur_pkt.dts);
736                 s->cur_pkt.pts = AV_NOPTS_VALUE;
737                 s->cur_pkt.dts = AV_NOPTS_VALUE;
738                 /* increment read pointer */
739                 s->cur_ptr += len;
740                 s->cur_len -= len;
741                 
742                 /* return packet if any */
743                 if (pkt->size) {
744                 got_packet:
745                     pkt->duration = 0;
746                     pkt->stream_index = st->index;
747                     pkt->pts = st->parser->pts;
748                     pkt->dts = st->parser->dts;
749                     pkt->destruct = av_destruct_packet_nofree;
750                     compute_pkt_fields(s, st, st->parser, pkt);
751                     return 0;
752                 }
753             } else {
754                 /* free packet */
755                 av_free_packet(&s->cur_pkt); 
756                 s->cur_st = NULL;
757             }
758         } else {
759             /* read next packet */
760             ret = av_read_packet(s, &s->cur_pkt);
761             if (ret < 0) {
762                 if (ret == -EAGAIN)
763                     return ret;
764                 /* return the last frames, if any */
765                 for(i = 0; i < s->nb_streams; i++) {
766                     st = s->streams[i];
767                     if (st->parser) {
768                         av_parser_parse(st->parser, &st->codec, 
769                                         &pkt->data, &pkt->size, 
770                                         NULL, 0, 
771                                         AV_NOPTS_VALUE, AV_NOPTS_VALUE);
772                         if (pkt->size)
773                             goto got_packet;
774                     }
775                 }
776                 /* no more packets: really terminates parsing */
777                 return ret;
778             }
779             
780             st = s->streams[s->cur_pkt.stream_index];
781
782             s->cur_st = st;
783             s->cur_ptr = s->cur_pkt.data;
784             s->cur_len = s->cur_pkt.size;
785             if (st->need_parsing && !st->parser) {
786                 st->parser = av_parser_init(st->codec.codec_id);
787                 if (!st->parser) {
788                     /* no parser available : just output the raw packets */
789                     st->need_parsing = 0;
790                 }
791             }
792         }
793     }
794 }
795
796 /**
797  * Return the next frame of a stream. The returned packet is valid
798  * until the next av_read_frame() or until av_close_input_file() and
799  * must be freed with av_free_packet. For video, the packet contains
800  * exactly one frame. For audio, it contains an integer number of
801  * frames if each frame has a known fixed size (e.g. PCM or ADPCM
802  * data). If the audio frames have a variable size (e.g. MPEG audio),
803  * then it contains one frame.
804  * 
805  * pkt->pts, pkt->dts and pkt->duration are always set to correct
806  * values in AV_TIME_BASE unit (and guessed if the format cannot
807  * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
808  * has B frames, so it is better to rely on pkt->dts if you do not
809  * decompress the payload.
810  * 
811  * Return 0 if OK, < 0 if error or end of file.  
812  */
813 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
814 {
815     AVPacketList *pktl;
816
817     pktl = s->packet_buffer;
818     if (pktl) {
819         /* read packet from packet buffer, if there is data */
820         *pkt = pktl->pkt;
821         s->packet_buffer = pktl->next;
822         av_free(pktl);
823         return 0;
824     } else {
825         return av_read_frame_internal(s, pkt);
826     }
827 }
828
829 /* XXX: suppress the packet queue */
830 static void flush_packet_queue(AVFormatContext *s)
831 {
832     AVPacketList *pktl;
833
834     for(;;) {
835         pktl = s->packet_buffer;
836         if (!pktl) 
837             break;
838         s->packet_buffer = pktl->next;
839         av_free_packet(&pktl->pkt);
840         av_free(pktl);
841     }
842 }
843
844 /*******************************************************/
845 /* seek support */
846
847 int av_find_default_stream_index(AVFormatContext *s)
848 {
849     int i;
850     AVStream *st;
851
852     if (s->nb_streams <= 0)
853         return -1;
854     for(i = 0; i < s->nb_streams; i++) {
855         st = s->streams[i];
856         if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
857             return i;
858         }
859     }
860     return 0;
861 }
862
863 /* flush the frame reader */
864 static void av_read_frame_flush(AVFormatContext *s)
865 {
866     AVStream *st;
867     int i;
868
869     flush_packet_queue(s);
870
871     /* free previous packet */
872     if (s->cur_st) {
873         if (s->cur_st->parser)
874             av_free_packet(&s->cur_pkt);
875         s->cur_st = NULL;
876     }
877     /* fail safe */
878     s->cur_ptr = NULL;
879     s->cur_len = 0;
880     
881     /* for each stream, reset read state */
882     for(i = 0; i < s->nb_streams; i++) {
883         st = s->streams[i];
884         
885         if (st->parser) {
886             av_parser_close(st->parser);
887             st->parser = NULL;
888         }
889         st->last_IP_pts = AV_NOPTS_VALUE;
890         st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
891     }
892 }
893
894 /**
895  * add a index entry into a sorted list updateing if it is already there.
896  * @param timestamp timestamp in the timebase of the given stream
897  */
898 int av_add_index_entry(AVStream *st,
899                             int64_t pos, int64_t timestamp, int distance, int flags)
900 {
901     AVIndexEntry *entries, *ie;
902     int index;
903     
904     entries = av_fast_realloc(st->index_entries,
905                               &st->index_entries_allocated_size,
906                               (st->nb_index_entries + 1) * 
907                               sizeof(AVIndexEntry));
908     st->index_entries= entries;
909
910     index= av_index_search_timestamp(st, timestamp, 0);
911
912     if(index<0){
913         index= st->nb_index_entries++;
914         ie= &entries[index];
915         assert(index==0 || ie[-1].timestamp < timestamp);
916     }else{
917         ie= &entries[index];
918         if(ie->timestamp != timestamp){
919             assert(ie->timestamp > timestamp);
920             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
921             st->nb_index_entries++;
922         }else if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
923             distance= ie->min_distance;
924     }
925
926     ie->pos = pos;
927     ie->timestamp = timestamp;
928     ie->min_distance= distance;
929     ie->flags = flags;
930     
931     return index;
932 }
933
934 /* build an index for raw streams using a parser */
935 static void av_build_index_raw(AVFormatContext *s)
936 {
937     AVPacket pkt1, *pkt = &pkt1;
938     int ret;
939     AVStream *st;
940
941     st = s->streams[0];
942     av_read_frame_flush(s);
943     url_fseek(&s->pb, s->data_offset, SEEK_SET);
944
945     for(;;) {
946         ret = av_read_frame(s, pkt);
947         if (ret < 0)
948             break;
949         if (pkt->stream_index == 0 && st->parser &&
950             (pkt->flags & PKT_FLAG_KEY)) {
951             int64_t dts= av_rescale(pkt->dts, st->time_base.den, AV_TIME_BASE*(int64_t)st->time_base.num);
952             av_add_index_entry(st, st->parser->frame_offset, dts, 
953                             0, AVINDEX_KEYFRAME);
954         }
955         av_free_packet(pkt);
956     }
957 }
958
959 /* return TRUE if we deal with a raw stream (raw codec data and
960    parsing needed) */
961 static int is_raw_stream(AVFormatContext *s)
962 {
963     AVStream *st;
964
965     if (s->nb_streams != 1)
966         return 0;
967     st = s->streams[0];
968     if (!st->need_parsing)
969         return 0;
970     return 1;
971 }
972
973 /**
974  * gets the index for a specific timestamp.
975  * @param backward if non zero then the returned index will correspond to 
976  *                 the timestamp which is <= the requested one, if backward is 0 
977  *                 then it will be >=
978  * @return < 0 if no such timestamp could be found
979  */
980 int av_index_search_timestamp(AVStream *st, int wanted_timestamp, int backward)
981 {
982     AVIndexEntry *entries= st->index_entries;
983     int nb_entries= st->nb_index_entries;
984     int a, b, m;
985     int64_t timestamp;
986
987     a = - 1;
988     b = nb_entries;
989
990     while (b - a > 1) {
991         m = (a + b) >> 1;
992         timestamp = entries[m].timestamp;
993         if(timestamp >= wanted_timestamp)
994             b = m;
995         if(timestamp <= wanted_timestamp)
996             a = m;
997     }
998     m= backward ? a : b;
999
1000     if(m == nb_entries) 
1001         return -1;
1002     return  m;
1003 }
1004
1005 #define DEBUG_SEEK
1006
1007 /**
1008  * Does a binary search using av_index_search_timestamp() and AVCodec.read_timestamp().
1009  * this isnt supposed to be called directly by a user application, but by demuxers
1010  * @param target_ts target timestamp in the time base of the given stream
1011  * @param stream_index stream number
1012  */
1013 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1014     AVInputFormat *avif= s->iformat;
1015     int64_t pos_min, pos_max, pos, pos_limit;
1016     int64_t ts_min, ts_max, ts;
1017     int64_t start_pos;
1018     int index, no_change, i;
1019     AVStream *st;
1020
1021     if (stream_index < 0)
1022         return -1;
1023     
1024 #ifdef DEBUG_SEEK
1025     av_log(s, AV_LOG_DEBUG, "read_seek: %d %lld\n", stream_index, target_ts);
1026 #endif
1027
1028     ts_max=
1029     ts_min= AV_NOPTS_VALUE;
1030     pos_limit= -1; //gcc falsely says it may be uninitalized
1031
1032     st= s->streams[stream_index];
1033     if(st->index_entries){
1034         AVIndexEntry *e;
1035
1036         index= av_index_search_timestamp(st, target_ts, 1);
1037         index= FFMAX(index, 0);
1038         e= &st->index_entries[index];
1039
1040         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1041             pos_min= e->pos;
1042             ts_min= e->timestamp;
1043 #ifdef DEBUG_SEEK
1044         av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%llx dts_min=%lld\n", 
1045                pos_min,ts_min);
1046 #endif
1047         }else{
1048             assert(index==0);
1049         }
1050         index++;
1051         if(index < st->nb_index_entries){
1052             e= &st->index_entries[index];
1053             assert(e->timestamp >= target_ts);
1054             pos_max= e->pos;
1055             ts_max= e->timestamp;
1056             pos_limit= pos_max - e->min_distance;
1057 #ifdef DEBUG_SEEK
1058         av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%llx pos_limit=0x%llx dts_max=%lld\n", 
1059                pos_max,pos_limit, ts_max);
1060 #endif
1061         }
1062     }
1063
1064     if(ts_min == AV_NOPTS_VALUE){
1065         pos_min = s->data_offset;
1066         ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1067         if (ts_min == AV_NOPTS_VALUE)
1068             return -1;
1069     }
1070
1071     if(ts_max == AV_NOPTS_VALUE){
1072         int step= 1024;
1073         pos_max = url_filesize(url_fileno(&s->pb)) - 1;
1074         do{
1075             pos_max -= step;
1076             ts_max = avif->read_timestamp(s, stream_index, &pos_max, pos_max + step);
1077             step += step;
1078         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1079         if (ts_max == AV_NOPTS_VALUE)
1080             return -1;
1081         
1082         for(;;){
1083             int64_t tmp_pos= pos_max + 1;
1084             int64_t tmp_ts= avif->read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1085             if(tmp_ts == AV_NOPTS_VALUE)
1086                 break;
1087             ts_max= tmp_ts;
1088             pos_max= tmp_pos;
1089         }
1090         pos_limit= pos_max;
1091     }
1092
1093     no_change=0;
1094     while (pos_min < pos_limit) {
1095 #ifdef DEBUG_SEEK
1096         av_log(s, AV_LOG_DEBUG, "pos_min=0x%llx pos_max=0x%llx dts_min=%lld dts_max=%lld\n", 
1097                pos_min, pos_max,
1098                ts_min, ts_max);
1099 #endif
1100         assert(pos_limit <= pos_max);
1101
1102         if(no_change==0){
1103             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1104             // interpolate position (better than dichotomy)
1105             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1106                 + pos_min - approximate_keyframe_distance;
1107         }else if(no_change==1){
1108             // bisection, if interpolation failed to change min or max pos last time
1109             pos = (pos_min + pos_limit)>>1;
1110         }else{
1111             // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1112             pos=pos_min;
1113         }
1114         if(pos <= pos_min)
1115             pos= pos_min + 1;
1116         else if(pos > pos_limit)
1117             pos= pos_limit;
1118         start_pos= pos;
1119
1120         ts = avif->read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1121         if(pos == pos_max)
1122             no_change++;
1123         else
1124             no_change=0;
1125 #ifdef DEBUG_SEEK
1126 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);
1127 #endif
1128         assert(ts != AV_NOPTS_VALUE);
1129         if (target_ts <= ts) {
1130             pos_limit = start_pos - 1;
1131             pos_max = pos;
1132             ts_max = ts;
1133         }
1134         if (target_ts >= ts) {
1135             pos_min = pos;
1136             ts_min = ts;
1137         }
1138     }
1139     
1140     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1141     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1142 #ifdef DEBUG_SEEK
1143     pos_min = pos;
1144     ts_min = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1145     pos_min++;
1146     ts_max = avif->read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1147     av_log(s, AV_LOG_DEBUG, "pos=0x%llx %lld<=%lld<=%lld\n", 
1148            pos, ts_min, target_ts, ts_max);
1149 #endif
1150     /* do the seek */
1151     url_fseek(&s->pb, pos, SEEK_SET);
1152
1153     for(i = 0; i < s->nb_streams; i++) {
1154         AVStream *st2 = s->streams[i];
1155
1156         st->cur_dts = av_rescale(ts, 
1157                                  st2->time_base.den * (int64_t)st ->time_base.num,
1158                                  st ->time_base.den * (int64_t)st2->time_base.num);
1159     }
1160
1161     return 0;
1162 }
1163
1164 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1165     AVInputFormat *avif= s->iformat;
1166     int64_t pos_min, pos_max;
1167 #if 0
1168     AVStream *st;
1169
1170     if (stream_index < 0)
1171         return -1;
1172
1173     st= s->streams[stream_index];
1174 #endif
1175
1176     pos_min = s->data_offset;
1177     pos_max = url_filesize(url_fileno(&s->pb)) - 1;
1178
1179     if     (pos < pos_min) pos= pos_min;
1180     else if(pos > pos_max) pos= pos_max;
1181
1182     url_fseek(&s->pb, pos, SEEK_SET);
1183
1184 #if 0
1185     for(i = 0; i < s->nb_streams; i++) {
1186         st2 = s->streams[i];
1187
1188         st->cur_dts = av_rescale(ie->timestamp, 
1189                                  st2->time_base.den * (int64_t)st ->time_base.num,
1190                                  st ->time_base.den * (int64_t)st2->time_base.num);
1191     }
1192 #endif
1193     return 0;
1194 }
1195
1196 static int av_seek_frame_generic(AVFormatContext *s, 
1197                                  int stream_index, int64_t timestamp, int flags)
1198 {
1199     int index, i;
1200     AVStream *st;
1201     AVIndexEntry *ie;
1202
1203     if (!s->index_built) {
1204         if (is_raw_stream(s)) {
1205             av_build_index_raw(s);
1206         } else {
1207             return -1;
1208         }
1209         s->index_built = 1;
1210     }
1211
1212     st = s->streams[stream_index];
1213     index = av_index_search_timestamp(st, timestamp, flags & AVSEEK_FLAG_BACKWARD);
1214     if (index < 0)
1215         return -1;
1216
1217     /* now we have found the index, we can seek */
1218     ie = &st->index_entries[index];
1219     av_read_frame_flush(s);
1220     url_fseek(&s->pb, ie->pos, SEEK_SET);
1221
1222     for(i = 0; i < s->nb_streams; i++) {
1223         AVStream *st2 = s->streams[i];
1224
1225         st->cur_dts = av_rescale(ie->timestamp, 
1226                                  st2->time_base.den * (int64_t)st ->time_base.num,
1227                                  st ->time_base.den * (int64_t)st2->time_base.num);
1228     }
1229
1230     return 0;
1231 }
1232
1233 /**
1234  * Seek to the key frame at timestamp.
1235  * 'timestamp' in 'stream_index'.
1236  * @param stream_index If stream_index is (-1), a default
1237  * stream is selected, and timestamp is automatically converted 
1238  * from AV_TIME_BASE units to the stream specific time_base.
1239  * @param timestamp timestamp in AVStream.time_base units
1240  * @param flags flags which select direction and seeking mode
1241  * @return >= 0 on success
1242  */
1243 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1244 {
1245     int ret;
1246     AVStream *st;
1247     
1248     av_read_frame_flush(s);
1249     
1250     if(flags & AVSEEK_FLAG_BYTE)
1251         return av_seek_frame_byte(s, stream_index, timestamp, flags);
1252     
1253     if(stream_index < 0){
1254         stream_index= av_find_default_stream_index(s);
1255         if(stream_index < 0)
1256             return -1;
1257             
1258         st= s->streams[stream_index];
1259        /* timestamp for default must be expressed in AV_TIME_BASE units */
1260         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1261     }
1262     st= s->streams[stream_index];
1263
1264     /* first, we try the format specific seek */
1265     if (s->iformat->read_seek)
1266         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1267     else
1268         ret = -1;
1269     if (ret >= 0) {
1270         return 0;
1271     }
1272
1273     if(s->iformat->read_timestamp)
1274         return av_seek_frame_binary(s, stream_index, timestamp, flags);
1275     else
1276         return av_seek_frame_generic(s, stream_index, timestamp, flags);
1277 }
1278
1279 /*******************************************************/
1280
1281 /* return TRUE if the stream has accurate timings for at least one component */
1282 static int av_has_timings(AVFormatContext *ic)
1283 {
1284     int i;
1285     AVStream *st;
1286
1287     for(i = 0;i < ic->nb_streams; i++) {
1288         st = ic->streams[i];
1289         if (st->start_time != AV_NOPTS_VALUE &&
1290             st->duration != AV_NOPTS_VALUE)
1291             return 1;
1292     }
1293     return 0;
1294 }
1295
1296 /* estimate the stream timings from the one of each components. Also
1297    compute the global bitrate if possible */
1298 static void av_update_stream_timings(AVFormatContext *ic)
1299 {
1300     int64_t start_time, end_time, end_time1;
1301     int i;
1302     AVStream *st;
1303
1304     start_time = MAXINT64;
1305     end_time = MININT64;
1306     for(i = 0;i < ic->nb_streams; i++) {
1307         st = ic->streams[i];
1308         if (st->start_time != AV_NOPTS_VALUE) {
1309             if (st->start_time < start_time)
1310                 start_time = st->start_time;
1311             if (st->duration != AV_NOPTS_VALUE) {
1312                 end_time1 = st->start_time + st->duration;
1313                 if (end_time1 > end_time)
1314                     end_time = end_time1;
1315             }
1316         }
1317     }
1318     if (start_time != MAXINT64) {
1319         ic->start_time = start_time;
1320         if (end_time != MAXINT64) {
1321             ic->duration = end_time - start_time;
1322             if (ic->file_size > 0) {
1323                 /* compute the bit rate */
1324                 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE / 
1325                     (double)ic->duration;
1326             }
1327         }
1328     }
1329
1330 }
1331
1332 static void fill_all_stream_timings(AVFormatContext *ic)
1333 {
1334     int i;
1335     AVStream *st;
1336
1337     av_update_stream_timings(ic);
1338     for(i = 0;i < ic->nb_streams; i++) {
1339         st = ic->streams[i];
1340         if (st->start_time == AV_NOPTS_VALUE) {
1341             st->start_time = ic->start_time;
1342             st->duration = ic->duration;
1343         }
1344     }
1345 }
1346
1347 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1348 {
1349     int64_t filesize, duration;
1350     int bit_rate, i;
1351     AVStream *st;
1352
1353     /* if bit_rate is already set, we believe it */
1354     if (ic->bit_rate == 0) {
1355         bit_rate = 0;
1356         for(i=0;i<ic->nb_streams;i++) {
1357             st = ic->streams[i];
1358             bit_rate += st->codec.bit_rate;
1359         }
1360         ic->bit_rate = bit_rate;
1361     }
1362
1363     /* if duration is already set, we believe it */
1364     if (ic->duration == AV_NOPTS_VALUE && 
1365         ic->bit_rate != 0 && 
1366         ic->file_size != 0)  {
1367         filesize = ic->file_size;
1368         if (filesize > 0) {
1369             duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1370             for(i = 0; i < ic->nb_streams; i++) {
1371                 st = ic->streams[i];
1372                 if (st->start_time == AV_NOPTS_VALUE ||
1373                     st->duration == AV_NOPTS_VALUE) {
1374                     st->start_time = 0;
1375                     st->duration = duration;
1376                 }
1377             }
1378         }
1379     }
1380 }
1381
1382 #define DURATION_MAX_READ_SIZE 250000
1383
1384 /* only usable for MPEG-PS streams */
1385 static void av_estimate_timings_from_pts(AVFormatContext *ic)
1386 {
1387     AVPacket pkt1, *pkt = &pkt1;
1388     AVStream *st;
1389     int read_size, i, ret;
1390     int64_t start_time, end_time, end_time1;
1391     int64_t filesize, offset, duration;
1392     
1393     /* free previous packet */
1394     if (ic->cur_st && ic->cur_st->parser)
1395         av_free_packet(&ic->cur_pkt); 
1396     ic->cur_st = NULL;
1397
1398     /* flush packet queue */
1399     flush_packet_queue(ic);
1400
1401     for(i=0;i<ic->nb_streams;i++) {
1402         st = ic->streams[i];
1403         if (st->parser) {
1404             av_parser_close(st->parser);
1405             st->parser= NULL;
1406         }
1407     }
1408     
1409     /* we read the first packets to get the first PTS (not fully
1410        accurate, but it is enough now) */
1411     url_fseek(&ic->pb, 0, SEEK_SET);
1412     read_size = 0;
1413     for(;;) {
1414         if (read_size >= DURATION_MAX_READ_SIZE)
1415             break;
1416         /* if all info is available, we can stop */
1417         for(i = 0;i < ic->nb_streams; i++) {
1418             st = ic->streams[i];
1419             if (st->start_time == AV_NOPTS_VALUE)
1420                 break;
1421         }
1422         if (i == ic->nb_streams)
1423             break;
1424
1425         ret = av_read_packet(ic, pkt);
1426         if (ret != 0)
1427             break;
1428         read_size += pkt->size;
1429         st = ic->streams[pkt->stream_index];
1430         if (pkt->pts != AV_NOPTS_VALUE) {
1431             if (st->start_time == AV_NOPTS_VALUE)
1432                 st->start_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1433         }
1434         av_free_packet(pkt);
1435     }
1436
1437     /* we compute the minimum start_time and use it as default */
1438     start_time = MAXINT64;
1439     for(i = 0; i < ic->nb_streams; i++) {
1440         st = ic->streams[i];
1441         if (st->start_time != AV_NOPTS_VALUE &&
1442             st->start_time < start_time)
1443             start_time = st->start_time;
1444     }
1445     if (start_time != MAXINT64)
1446         ic->start_time = start_time;
1447     
1448     /* estimate the end time (duration) */
1449     /* XXX: may need to support wrapping */
1450     filesize = ic->file_size;
1451     offset = filesize - DURATION_MAX_READ_SIZE;
1452     if (offset < 0)
1453         offset = 0;
1454
1455     url_fseek(&ic->pb, offset, SEEK_SET);
1456     read_size = 0;
1457     for(;;) {
1458         if (read_size >= DURATION_MAX_READ_SIZE)
1459             break;
1460         /* if all info is available, we can stop */
1461         for(i = 0;i < ic->nb_streams; i++) {
1462             st = ic->streams[i];
1463             if (st->duration == AV_NOPTS_VALUE)
1464                 break;
1465         }
1466         if (i == ic->nb_streams)
1467             break;
1468         
1469         ret = av_read_packet(ic, pkt);
1470         if (ret != 0)
1471             break;
1472         read_size += pkt->size;
1473         st = ic->streams[pkt->stream_index];
1474         if (pkt->pts != AV_NOPTS_VALUE) {
1475             end_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1476             duration = end_time - st->start_time;
1477             if (duration > 0) {
1478                 if (st->duration == AV_NOPTS_VALUE ||
1479                     st->duration < duration)
1480                     st->duration = duration;
1481             }
1482         }
1483         av_free_packet(pkt);
1484     }
1485     
1486     /* estimate total duration */
1487     end_time = MININT64;
1488     for(i = 0;i < ic->nb_streams; i++) {
1489         st = ic->streams[i];
1490         if (st->duration != AV_NOPTS_VALUE) {
1491             end_time1 = st->start_time + st->duration;
1492             if (end_time1 > end_time)
1493                 end_time = end_time1;
1494         }
1495     }
1496     
1497     /* update start_time (new stream may have been created, so we do
1498        it at the end */
1499     if (ic->start_time != AV_NOPTS_VALUE) {
1500         for(i = 0; i < ic->nb_streams; i++) {
1501             st = ic->streams[i];
1502             if (st->start_time == AV_NOPTS_VALUE)
1503                 st->start_time = ic->start_time;
1504         }
1505     }
1506
1507     if (end_time != MININT64) {
1508         /* put dummy values for duration if needed */
1509         for(i = 0;i < ic->nb_streams; i++) {
1510             st = ic->streams[i];
1511             if (st->duration == AV_NOPTS_VALUE && 
1512                 st->start_time != AV_NOPTS_VALUE)
1513                 st->duration = end_time - st->start_time;
1514         }
1515         ic->duration = end_time - ic->start_time;
1516     }
1517
1518     url_fseek(&ic->pb, 0, SEEK_SET);
1519 }
1520
1521 static void av_estimate_timings(AVFormatContext *ic)
1522 {
1523     URLContext *h;
1524     int64_t file_size;
1525
1526     /* get the file size, if possible */
1527     if (ic->iformat->flags & AVFMT_NOFILE) {
1528         file_size = 0;
1529     } else {
1530         h = url_fileno(&ic->pb);
1531         file_size = url_filesize(h);
1532         if (file_size < 0)
1533             file_size = 0;
1534     }
1535     ic->file_size = file_size;
1536
1537     if (ic->iformat == &mpegps_demux) {
1538         /* get accurate estimate from the PTSes */
1539         av_estimate_timings_from_pts(ic);
1540     } else if (av_has_timings(ic)) {
1541         /* at least one components has timings - we use them for all
1542            the components */
1543         fill_all_stream_timings(ic);
1544     } else {
1545         /* less precise: use bit rate info */
1546         av_estimate_timings_from_bit_rate(ic);
1547     }
1548     av_update_stream_timings(ic);
1549
1550 #if 0
1551     {
1552         int i;
1553         AVStream *st;
1554         for(i = 0;i < ic->nb_streams; i++) {
1555             st = ic->streams[i];
1556         printf("%d: start_time: %0.3f duration: %0.3f\n", 
1557                i, (double)st->start_time / AV_TIME_BASE, 
1558                (double)st->duration / AV_TIME_BASE);
1559         }
1560         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n", 
1561                (double)ic->start_time / AV_TIME_BASE, 
1562                (double)ic->duration / AV_TIME_BASE,
1563                ic->bit_rate / 1000);
1564     }
1565 #endif
1566 }
1567
1568 static int has_codec_parameters(AVCodecContext *enc)
1569 {
1570     int val;
1571     switch(enc->codec_type) {
1572     case CODEC_TYPE_AUDIO:
1573         val = enc->sample_rate;
1574         break;
1575     case CODEC_TYPE_VIDEO:
1576         val = enc->width;
1577         break;
1578     default:
1579         val = 1;
1580         break;
1581     }
1582     return (val != 0);
1583 }
1584
1585 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1586 {
1587     int16_t *samples;
1588     AVCodec *codec;
1589     int got_picture, ret;
1590     AVFrame picture;
1591     
1592     codec = avcodec_find_decoder(st->codec.codec_id);
1593     if (!codec)
1594         return -1;
1595     ret = avcodec_open(&st->codec, codec);
1596     if (ret < 0)
1597         return ret;
1598     switch(st->codec.codec_type) {
1599     case CODEC_TYPE_VIDEO:
1600         ret = avcodec_decode_video(&st->codec, &picture, 
1601                                    &got_picture, (uint8_t *)data, size);
1602         break;
1603     case CODEC_TYPE_AUDIO:
1604         samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1605         if (!samples)
1606             goto fail;
1607         ret = avcodec_decode_audio(&st->codec, samples, 
1608                                    &got_picture, (uint8_t *)data, size);
1609         av_free(samples);
1610         break;
1611     default:
1612         break;
1613     }
1614  fail:
1615     avcodec_close(&st->codec);
1616     return ret;
1617 }
1618
1619 /* absolute maximum size we read until we abort */
1620 #define MAX_READ_SIZE        5000000
1621
1622 /* maximum duration until we stop analysing the stream */
1623 #define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 1.0))
1624
1625 /**
1626  * Read the beginning of a media file to get stream information. This
1627  * is useful for file formats with no headers such as MPEG. This
1628  * function also compute the real frame rate in case of mpeg2 repeat
1629  * frame mode.
1630  *
1631  * @param ic media file handle
1632  * @return >=0 if OK. AVERROR_xxx if error.  
1633  */
1634 int av_find_stream_info(AVFormatContext *ic)
1635 {
1636     int i, count, ret, read_size;
1637     AVStream *st;
1638     AVPacket pkt1, *pkt;
1639     AVPacketList *pktl=NULL, **ppktl;
1640
1641     count = 0;
1642     read_size = 0;
1643     ppktl = &ic->packet_buffer;
1644     for(;;) {
1645         /* check if one codec still needs to be handled */
1646         for(i=0;i<ic->nb_streams;i++) {
1647             st = ic->streams[i];
1648             if (!has_codec_parameters(&st->codec))
1649                 break;
1650         }
1651         if (i == ic->nb_streams) {
1652             /* NOTE: if the format has no header, then we need to read
1653                some packets to get most of the streams, so we cannot
1654                stop here */
1655             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1656                 /* if we found the info for all the codecs, we can stop */
1657                 ret = count;
1658                 break;
1659             }
1660         } else {
1661             /* we did not get all the codec info, but we read too much data */
1662             if (read_size >= MAX_READ_SIZE) {
1663                 ret = count;
1664                 break;
1665             }
1666         }
1667
1668         /* NOTE: a new stream can be added there if no header in file
1669            (AVFMTCTX_NOHEADER) */
1670         ret = av_read_frame_internal(ic, &pkt1);
1671         if (ret < 0) {
1672             /* EOF or error */
1673             ret = -1; /* we could not have all the codec parameters before EOF */
1674             if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1675                 i == ic->nb_streams)
1676                 ret = 0;
1677             break;
1678         }
1679
1680         pktl = av_mallocz(sizeof(AVPacketList));
1681         if (!pktl) {
1682             ret = AVERROR_NOMEM;
1683             break;
1684         }
1685
1686         /* add the packet in the buffered packet list */
1687         *ppktl = pktl;
1688         ppktl = &pktl->next;
1689
1690         pkt = &pktl->pkt;
1691         *pkt = pkt1;
1692         
1693         /* duplicate the packet */
1694         if (av_dup_packet(pkt) < 0) {
1695                 ret = AVERROR_NOMEM;
1696                 break;
1697         }
1698
1699         read_size += pkt->size;
1700
1701         st = ic->streams[pkt->stream_index];
1702         st->codec_info_duration += pkt->duration;
1703         if (pkt->duration != 0)
1704             st->codec_info_nb_frames++;
1705
1706         /* if still no information, we try to open the codec and to
1707            decompress the frame. We try to avoid that in most cases as
1708            it takes longer and uses more memory. For MPEG4, we need to
1709            decompress for Quicktime. */
1710         if (!has_codec_parameters(&st->codec) &&
1711             (st->codec.codec_id == CODEC_ID_FLV1 ||
1712              st->codec.codec_id == CODEC_ID_H264 ||
1713              st->codec.codec_id == CODEC_ID_H263 ||
1714              st->codec.codec_id == CODEC_ID_VORBIS ||
1715              st->codec.codec_id == CODEC_ID_MJPEG ||
1716              (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1717             try_decode_frame(st, pkt->data, pkt->size);
1718         
1719         if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1720             break;
1721         }
1722         count++;
1723     }
1724
1725     /* set real frame rate info */
1726     for(i=0;i<ic->nb_streams;i++) {
1727         st = ic->streams[i];
1728         if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1729             /* compute the real frame rate for telecine */
1730             if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1731                  st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1732                 st->codec.sub_id == 2) {
1733                 if (st->codec_info_nb_frames >= 20) {
1734                     float coded_frame_rate, est_frame_rate;
1735                     est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) / 
1736                         (double)st->codec_info_duration ;
1737                     coded_frame_rate = (double)st->codec.frame_rate /
1738                         (double)st->codec.frame_rate_base;
1739 #if 0
1740                     printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n", 
1741                            coded_frame_rate, est_frame_rate);
1742 #endif
1743                     /* if we detect that it could be a telecine, we
1744                        signal it. It would be better to do it at a
1745                        higher level as it can change in a film */
1746                     if (coded_frame_rate >= 24.97 && 
1747                         (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1748                         st->r_frame_rate = 24024;
1749                         st->r_frame_rate_base = 1001;
1750                     }
1751                 }
1752             }
1753             /* if no real frame rate, use the codec one */
1754             if (!st->r_frame_rate){
1755                 st->r_frame_rate      = st->codec.frame_rate;
1756                 st->r_frame_rate_base = st->codec.frame_rate_base;
1757             }
1758         }
1759     }
1760
1761     av_estimate_timings(ic);
1762 #if 0
1763     /* correct DTS for b frame streams with no timestamps */
1764     for(i=0;i<ic->nb_streams;i++) {
1765         st = ic->streams[i];
1766         if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1767             if(b-frames){
1768                 ppktl = &ic->packet_buffer;
1769                 while(ppkt1){
1770                     if(ppkt1->stream_index != i)
1771                         continue;
1772                     if(ppkt1->pkt->dts < 0)
1773                         break;
1774                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1775                         break;
1776                     ppkt1->pkt->dts -= delta;
1777                     ppkt1= ppkt1->next;
1778                 }
1779                 if(ppkt1)
1780                     continue;
1781                 st->cur_dts -= delta;
1782             }
1783         }
1784     }
1785 #endif
1786     return ret;
1787 }
1788
1789 /*******************************************************/
1790
1791 /**
1792  * start playing a network based stream (e.g. RTSP stream) at the
1793  * current position 
1794  */
1795 int av_read_play(AVFormatContext *s)
1796 {
1797     if (!s->iformat->read_play)
1798         return AVERROR_NOTSUPP;
1799     return s->iformat->read_play(s);
1800 }
1801
1802 /**
1803  * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1804  * to resume it.
1805  */
1806 int av_read_pause(AVFormatContext *s)
1807 {
1808     if (!s->iformat->read_pause)
1809         return AVERROR_NOTSUPP;
1810     return s->iformat->read_pause(s);
1811 }
1812
1813 /**
1814  * Close a media file (but not its codecs)
1815  *
1816  * @param s media file handle
1817  */
1818 void av_close_input_file(AVFormatContext *s)
1819 {
1820     int i, must_open_file;
1821     AVStream *st;
1822
1823     /* free previous packet */
1824     if (s->cur_st && s->cur_st->parser)
1825         av_free_packet(&s->cur_pkt); 
1826
1827     if (s->iformat->read_close)
1828         s->iformat->read_close(s);
1829     for(i=0;i<s->nb_streams;i++) {
1830         /* free all data in a stream component */
1831         st = s->streams[i];
1832         if (st->parser) {
1833             av_parser_close(st->parser);
1834         }
1835         av_free(st->index_entries);
1836         av_free(st);
1837     }
1838     flush_packet_queue(s);
1839     must_open_file = 1;
1840     if (s->iformat->flags & AVFMT_NOFILE) {
1841         must_open_file = 0;
1842     }
1843     if (must_open_file) {
1844         url_fclose(&s->pb);
1845     }
1846     av_freep(&s->priv_data);
1847     av_free(s);
1848 }
1849
1850 /**
1851  * Add a new stream to a media file. Can only be called in the
1852  * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1853  * format context, then new streams can be added in read_packet too.
1854  *
1855  *
1856  * @param s media file handle
1857  * @param id file format dependent stream id 
1858  */
1859 AVStream *av_new_stream(AVFormatContext *s, int id)
1860 {
1861     AVStream *st;
1862
1863     if (s->nb_streams >= MAX_STREAMS)
1864         return NULL;
1865
1866     st = av_mallocz(sizeof(AVStream));
1867     if (!st)
1868         return NULL;
1869     avcodec_get_context_defaults(&st->codec);
1870     if (s->iformat) {
1871         /* no default bitrate if decoding */
1872         st->codec.bit_rate = 0;
1873     }
1874     st->index = s->nb_streams;
1875     st->id = id;
1876     st->start_time = AV_NOPTS_VALUE;
1877     st->duration = AV_NOPTS_VALUE;
1878     st->cur_dts = AV_NOPTS_VALUE;
1879
1880     /* default pts settings is MPEG like */
1881     av_set_pts_info(st, 33, 1, 90000);
1882     st->last_IP_pts = AV_NOPTS_VALUE;
1883
1884     s->streams[s->nb_streams++] = st;
1885     return st;
1886 }
1887
1888 /************************************************************/
1889 /* output media file */
1890
1891 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1892 {
1893     int ret;
1894     
1895     if (s->oformat->priv_data_size > 0) {
1896         s->priv_data = av_mallocz(s->oformat->priv_data_size);
1897         if (!s->priv_data)
1898             return AVERROR_NOMEM;
1899     } else
1900         s->priv_data = NULL;
1901         
1902     if (s->oformat->set_parameters) {
1903         ret = s->oformat->set_parameters(s, ap);
1904         if (ret < 0)
1905             return ret;
1906     }
1907     return 0;
1908 }
1909
1910 /**
1911  * allocate the stream private data and write the stream header to an
1912  * output media file
1913  *
1914  * @param s media file handle
1915  * @return 0 if OK. AVERROR_xxx if error.  
1916  */
1917 int av_write_header(AVFormatContext *s)
1918 {
1919     int ret, i;
1920     AVStream *st;
1921
1922     ret = s->oformat->write_header(s);
1923     if (ret < 0)
1924         return ret;
1925
1926     /* init PTS generation */
1927     for(i=0;i<s->nb_streams;i++) {
1928         st = s->streams[i];
1929
1930         switch (st->codec.codec_type) {
1931         case CODEC_TYPE_AUDIO:
1932             av_frac_init(&st->pts, 0, 0, 
1933                          (int64_t)st->time_base.num * st->codec.sample_rate);
1934             break;
1935         case CODEC_TYPE_VIDEO:
1936             av_frac_init(&st->pts, 0, 0, 
1937                          (int64_t)st->time_base.num * st->codec.frame_rate);
1938             break;
1939         default:
1940             break;
1941         }
1942     }
1943     return 0;
1944 }
1945
1946 //FIXME merge with compute_pkt_fields
1947 static void compute_pkt_fields2(AVStream *st, AVPacket *pkt){
1948     int b_frames = FFMAX(st->codec.has_b_frames, st->codec.max_b_frames);
1949     int num, den, frame_size;
1950
1951 //    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts:%lld dts:%lld cur_dts:%lld b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, b_frames, pkt->size, pkt->stream_index);
1952     
1953 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
1954         return -1;*/
1955             
1956     if(pkt->pts != AV_NOPTS_VALUE)
1957         pkt->pts = av_rescale(pkt->pts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1958     if(pkt->dts != AV_NOPTS_VALUE)
1959         pkt->dts = av_rescale(pkt->dts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1960
1961     /* duration field */
1962     pkt->duration = av_rescale(pkt->duration, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1963     if (pkt->duration == 0) {
1964         compute_frame_duration(&num, &den, st, NULL, pkt);
1965         if (den && num) {
1966             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
1967         }
1968     }
1969
1970     //XXX/FIXME this is a temporary hack until all encoders output pts
1971     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
1972         pkt->dts=
1973 //        pkt->pts= st->cur_dts;
1974         pkt->pts= st->pts.val;
1975     }
1976
1977     //calculate dts from pts    
1978     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
1979         if(b_frames){
1980             if(st->last_IP_pts == AV_NOPTS_VALUE){
1981                 st->last_IP_pts= -pkt->duration;
1982             }
1983             if(st->last_IP_pts < pkt->pts){
1984                 pkt->dts= st->last_IP_pts;
1985                 st->last_IP_pts= pkt->pts;
1986             }else
1987                 pkt->dts= pkt->pts;
1988         }else
1989             pkt->dts= pkt->pts;
1990     }
1991     
1992 //    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
1993     st->cur_dts= pkt->dts;
1994     st->pts.val= pkt->dts;
1995
1996     /* update pts */
1997     switch (st->codec.codec_type) {
1998     case CODEC_TYPE_AUDIO:
1999         frame_size = get_audio_frame_size(&st->codec, pkt->size);
2000
2001         /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2002            but it would be better if we had the real timestamps from the encoder */
2003         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2004             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2005         }
2006         break;
2007     case CODEC_TYPE_VIDEO:
2008         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec.frame_rate_base);
2009         break;
2010     default:
2011         break;
2012     }
2013 }
2014
2015 static void truncate_ts(AVStream *st, AVPacket *pkt){
2016     int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2017     
2018 //    if(pkt->dts < 0)
2019 //        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2020     
2021     pkt->pts &= pts_mask;
2022     pkt->dts &= pts_mask;
2023 }
2024
2025 /**
2026  * Write a packet to an output media file. The packet shall contain
2027  * one audio or video frame.
2028  *
2029  * @param s media file handle
2030  * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2031  * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2032  */
2033 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2034 {
2035     int ret;
2036
2037     compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2038     
2039     truncate_ts(s->streams[pkt->stream_index], pkt);
2040
2041     ret= s->oformat->write_packet(s, pkt);
2042     if(!ret)
2043         ret= url_ferror(&s->pb);
2044     return ret;
2045 }
2046
2047 /**
2048  * interleave_packet implementation which will interleave per DTS.
2049  */
2050 static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2051     AVPacketList *pktl, **next_point, *this_pktl;
2052     int stream_count=0;
2053     int streams[MAX_STREAMS];
2054
2055     if(pkt){
2056         AVStream *st= s->streams[ pkt->stream_index];
2057
2058         assert(pkt->destruct != av_destruct_packet); //FIXME
2059
2060         this_pktl = av_mallocz(sizeof(AVPacketList));
2061         this_pktl->pkt= *pkt;
2062         av_dup_packet(&this_pktl->pkt);
2063
2064         next_point = &s->packet_buffer;
2065         while(*next_point){
2066             AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2067             int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2068             int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2069             if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2070                 break;
2071             next_point= &(*next_point)->next;
2072         }
2073         this_pktl->next= *next_point;
2074         *next_point= this_pktl;
2075     }
2076     
2077     memset(streams, 0, sizeof(streams));
2078     pktl= s->packet_buffer;
2079     while(pktl){
2080 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2081         if(streams[ pktl->pkt.stream_index ] == 0)
2082             stream_count++;
2083         streams[ pktl->pkt.stream_index ]++;
2084         pktl= pktl->next;
2085     }
2086     
2087     if(s->nb_streams == stream_count || (flush && stream_count)){
2088         pktl= s->packet_buffer;
2089         *out= pktl->pkt;
2090         
2091         s->packet_buffer= pktl->next;        
2092         av_freep(&pktl);
2093         return 1;
2094     }else{
2095         av_init_packet(out);
2096         return 0;
2097     }
2098 }
2099
2100 /**
2101  * Interleaves a AVPacket correctly so it can be muxed.
2102  * @param out the interleaved packet will be output here
2103  * @param in the input packet
2104  * @param flush 1 if no further packets are available as input and all
2105  *              remaining packets should be output
2106  * @return 1 if a packet was output, 0 if no packet could be output, 
2107  *         < 0 if an error occured
2108  */
2109 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2110     if(s->oformat->interleave_packet)
2111         return s->oformat->interleave_packet(s, out, in, flush);
2112     else
2113         return av_interleave_packet_per_dts(s, out, in, flush);
2114 }
2115
2116 /**
2117  * Writes a packet to an output media file ensuring correct interleaving. 
2118  * The packet shall contain one audio or video frame.
2119  * If the packets are already correctly interleaved the application should
2120  * call av_write_frame() instead as its slightly faster, its also important
2121  * to keep in mind that completly non interleaved input will need huge amounts
2122  * of memory to interleave with this, so its prefereable to interleave at the
2123  * demuxer level
2124  *
2125  * @param s media file handle
2126  * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2127  * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2128  */
2129 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2130     AVStream *st= s->streams[ pkt->stream_index];
2131
2132     compute_pkt_fields2(st, pkt);
2133     
2134     //FIXME/XXX/HACK drop zero sized packets
2135     if(st->codec.codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2136         return 0;
2137     
2138     if(pkt->dts == AV_NOPTS_VALUE)
2139         return -1;
2140
2141     for(;;){
2142         AVPacket opkt;
2143         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2144         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2145             return ret;
2146         
2147         truncate_ts(s->streams[opkt.stream_index], &opkt);
2148         ret= s->oformat->write_packet(s, &opkt);
2149         
2150         av_free_packet(&opkt);
2151         pkt= NULL;
2152         
2153         if(ret<0)
2154             return ret;
2155         if(url_ferror(&s->pb))
2156             return url_ferror(&s->pb);
2157     }
2158 }
2159
2160 /**
2161  * write the stream trailer to an output media file and and free the
2162  * file private data.
2163  *
2164  * @param s media file handle
2165  * @return 0 if OK. AVERROR_xxx if error.  */
2166 int av_write_trailer(AVFormatContext *s)
2167 {
2168     int ret, i;
2169     
2170     for(;;){
2171         AVPacket pkt;
2172         ret= av_interleave_packet(s, &pkt, NULL, 1);
2173         if(ret<0) //FIXME cleanup needed for ret<0 ?
2174             goto fail;
2175         if(!ret)
2176             break;
2177         
2178         truncate_ts(s->streams[pkt.stream_index], &pkt);
2179         ret= s->oformat->write_packet(s, &pkt);
2180         
2181         av_free_packet(&pkt);
2182         
2183         if(ret<0)
2184             goto fail;
2185         if(url_ferror(&s->pb))
2186             goto fail;
2187     }
2188
2189     ret = s->oformat->write_trailer(s);
2190 fail:
2191     if(ret == 0)
2192        ret=url_ferror(&s->pb);
2193     for(i=0;i<s->nb_streams;i++)
2194         av_freep(&s->streams[i]->priv_data);
2195     av_freep(&s->priv_data);
2196     return ret;
2197 }
2198
2199 /* "user interface" functions */
2200
2201 void dump_format(AVFormatContext *ic,
2202                  int index, 
2203                  const char *url,
2204                  int is_output)
2205 {
2206     int i, flags;
2207     char buf[256];
2208
2209     av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n", 
2210             is_output ? "Output" : "Input",
2211             index, 
2212             is_output ? ic->oformat->name : ic->iformat->name, 
2213             is_output ? "to" : "from", url);
2214     if (!is_output) {
2215         av_log(NULL, AV_LOG_DEBUG, "  Duration: ");
2216         if (ic->duration != AV_NOPTS_VALUE) {
2217             int hours, mins, secs, us;
2218             secs = ic->duration / AV_TIME_BASE;
2219             us = ic->duration % AV_TIME_BASE;
2220             mins = secs / 60;
2221             secs %= 60;
2222             hours = mins / 60;
2223             mins %= 60;
2224             av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs, 
2225                    (10 * us) / AV_TIME_BASE);
2226         } else {
2227             av_log(NULL, AV_LOG_DEBUG, "N/A");
2228         }
2229         if (ic->start_time != AV_NOPTS_VALUE) {
2230             int secs, us;
2231             av_log(NULL, AV_LOG_DEBUG, ", start: ");
2232             secs = ic->start_time / AV_TIME_BASE;
2233             us = ic->start_time % AV_TIME_BASE;
2234             av_log(NULL, AV_LOG_DEBUG, "%d.%06d",
2235                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2236         }
2237         av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
2238         if (ic->bit_rate) {
2239             av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
2240         } else {
2241             av_log(NULL, AV_LOG_DEBUG, "N/A");
2242         }
2243         av_log(NULL, AV_LOG_DEBUG, "\n");
2244     }
2245     for(i=0;i<ic->nb_streams;i++) {
2246         AVStream *st = ic->streams[i];
2247         avcodec_string(buf, sizeof(buf), &st->codec, is_output);
2248         av_log(NULL, AV_LOG_DEBUG, "  Stream #%d.%d", index, i);
2249         /* the pid is an important information, so we display it */
2250         /* XXX: add a generic system */
2251         if (is_output)
2252             flags = ic->oformat->flags;
2253         else
2254             flags = ic->iformat->flags;
2255         if (flags & AVFMT_SHOW_IDS) {
2256             av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
2257         }
2258         av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
2259     }
2260 }
2261
2262 typedef struct {
2263     const char *abv;
2264     int width, height;
2265     int frame_rate, frame_rate_base;
2266 } AbvEntry;
2267
2268 static AbvEntry frame_abvs[] = {
2269     { "ntsc",      720, 480, 30000, 1001 },
2270     { "pal",       720, 576,    25,    1 },
2271     { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2272     { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2273     { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2274     { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2275     { "film",      352, 240,    24,    1 },
2276     { "ntsc-film", 352, 240, 24000, 1001 },
2277     { "sqcif",     128,  96,     0,    0 },
2278     { "qcif",      176, 144,     0,    0 },
2279     { "cif",       352, 288,     0,    0 },
2280     { "4cif",      704, 576,     0,    0 },
2281 };
2282
2283 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2284 {
2285     int i;
2286     int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2287     const char *p;
2288     int frame_width = 0, frame_height = 0;
2289
2290     for(i=0;i<n;i++) {
2291         if (!strcmp(frame_abvs[i].abv, str)) {
2292             frame_width = frame_abvs[i].width;
2293             frame_height = frame_abvs[i].height;
2294             break;
2295         }
2296     }
2297     if (i == n) {
2298         p = str;
2299         frame_width = strtol(p, (char **)&p, 10);
2300         if (*p)
2301             p++;
2302         frame_height = strtol(p, (char **)&p, 10);
2303     }
2304     if (frame_width <= 0 || frame_height <= 0)
2305         return -1;
2306     *width_ptr = frame_width;
2307     *height_ptr = frame_height;
2308     return 0;
2309 }
2310
2311 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2312 {
2313     int i;
2314     char* cp;
2315    
2316     /* First, we check our abbreviation table */
2317     for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2318          if (!strcmp(frame_abvs[i].abv, arg)) {
2319              *frame_rate = frame_abvs[i].frame_rate;
2320              *frame_rate_base = frame_abvs[i].frame_rate_base;
2321              return 0;
2322          }
2323
2324     /* Then, we try to parse it as fraction */
2325     cp = strchr(arg, '/');
2326     if (cp) {
2327         char* cpp;
2328         *frame_rate = strtol(arg, &cpp, 10);
2329         if (cpp != arg || cpp == cp) 
2330             *frame_rate_base = strtol(cp+1, &cpp, 10);
2331         else
2332            *frame_rate = 0;
2333     } 
2334     else {
2335         /* Finally we give up and parse it as double */
2336         *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
2337         *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
2338     }
2339     if (!*frame_rate || !*frame_rate_base)
2340         return -1;
2341     else
2342         return 0;
2343 }
2344
2345 /* Syntax:
2346  * - If not a duration:
2347  *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2348  * Time is localtime unless Z is suffixed to the end. In this case GMT
2349  * Return the date in micro seconds since 1970 
2350  * - If duration:
2351  *  HH[:MM[:SS[.m...]]]
2352  *  S+[.m...]
2353  */
2354 int64_t parse_date(const char *datestr, int duration)
2355 {
2356     const char *p;
2357     int64_t t;
2358     struct tm dt;
2359     int i;
2360     static const char *date_fmt[] = {
2361         "%Y-%m-%d",
2362         "%Y%m%d",
2363     };
2364     static const char *time_fmt[] = {
2365         "%H:%M:%S",
2366         "%H%M%S",
2367     };
2368     const char *q;
2369     int is_utc, len;
2370     char lastch;
2371     int negative = 0;
2372
2373 #undef time
2374     time_t now = time(0);
2375
2376     len = strlen(datestr);
2377     if (len > 0)
2378         lastch = datestr[len - 1];
2379     else
2380         lastch = '\0';
2381     is_utc = (lastch == 'z' || lastch == 'Z');
2382
2383     memset(&dt, 0, sizeof(dt));
2384
2385     p = datestr;
2386     q = NULL;
2387     if (!duration) {
2388         for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2389             q = small_strptime(p, date_fmt[i], &dt);
2390             if (q) {
2391                 break;
2392             }
2393         }
2394
2395         if (!q) {
2396             if (is_utc) {
2397                 dt = *gmtime(&now);
2398             } else {
2399                 dt = *localtime(&now);
2400             }
2401             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2402         } else {
2403             p = q;
2404         }
2405
2406         if (*p == 'T' || *p == 't' || *p == ' ')
2407             p++;
2408
2409         for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2410             q = small_strptime(p, time_fmt[i], &dt);
2411             if (q) {
2412                 break;
2413             }
2414         }
2415     } else {
2416         if (p[0] == '-') {
2417             negative = 1;
2418             ++p;
2419         }
2420         q = small_strptime(p, time_fmt[0], &dt);
2421         if (!q) {
2422             dt.tm_sec = strtol(p, (char **)&q, 10);
2423             dt.tm_min = 0;
2424             dt.tm_hour = 0;
2425         }
2426     }
2427
2428     /* Now we have all the fields that we can get */
2429     if (!q) {
2430         if (duration)
2431             return 0;
2432         else
2433             return now * int64_t_C(1000000);
2434     }
2435
2436     if (duration) {
2437         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2438     } else {
2439         dt.tm_isdst = -1;       /* unknown */
2440         if (is_utc) {
2441             t = mktimegm(&dt);
2442         } else {
2443             t = mktime(&dt);
2444         }
2445     }
2446
2447     t *= 1000000;
2448
2449     if (*q == '.') {
2450         int val, n;
2451         q++;
2452         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2453             if (!isdigit(*q)) 
2454                 break;
2455             val += n * (*q - '0');
2456         }
2457         t += val;
2458     }
2459     return negative ? -t : t;
2460 }
2461
2462 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
2463    1 if found */
2464 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2465 {
2466     const char *p;
2467     char tag[128], *q;
2468
2469     p = info;
2470     if (*p == '?')
2471         p++;
2472     for(;;) {
2473         q = tag;
2474         while (*p != '\0' && *p != '=' && *p != '&') {
2475             if ((q - tag) < sizeof(tag) - 1)
2476                 *q++ = *p;
2477             p++;
2478         }
2479         *q = '\0';
2480         q = arg;
2481         if (*p == '=') {
2482             p++;
2483             while (*p != '&' && *p != '\0') {
2484                 if ((q - arg) < arg_size - 1) {
2485                     if (*p == '+')
2486                         *q++ = ' ';
2487                     else
2488                         *q++ = *p;
2489                 }
2490                 p++;
2491             }
2492             *q = '\0';
2493         }
2494         if (!strcmp(tag, tag1)) 
2495             return 1;
2496         if (*p != '&')
2497             break;
2498         p++;
2499     }
2500     return 0;
2501 }
2502
2503 /* Return in 'buf' the path with '%d' replaced by number. Also handles
2504    the '%0nd' format where 'n' is the total number of digits and
2505    '%%'. Return 0 if OK, and -1 if format error */
2506 int get_frame_filename(char *buf, int buf_size,
2507                        const char *path, int number)
2508 {
2509     const char *p;
2510     char *q, buf1[20], c;
2511     int nd, len, percentd_found;
2512
2513     q = buf;
2514     p = path;
2515     percentd_found = 0;
2516     for(;;) {
2517         c = *p++;
2518         if (c == '\0')
2519             break;
2520         if (c == '%') {
2521             do {
2522                 nd = 0;
2523                 while (isdigit(*p)) {
2524                     nd = nd * 10 + *p++ - '0';
2525                 }
2526                 c = *p++;
2527             } while (isdigit(c));
2528
2529             switch(c) {
2530             case '%':
2531                 goto addchar;
2532             case 'd':
2533                 if (percentd_found)
2534                     goto fail;
2535                 percentd_found = 1;
2536                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2537                 len = strlen(buf1);
2538                 if ((q - buf + len) > buf_size - 1)
2539                     goto fail;
2540                 memcpy(q, buf1, len);
2541                 q += len;
2542                 break;
2543             default:
2544                 goto fail;
2545             }
2546         } else {
2547         addchar:
2548             if ((q - buf) < buf_size - 1)
2549                 *q++ = c;
2550         }
2551     }
2552     if (!percentd_found)
2553         goto fail;
2554     *q = '\0';
2555     return 0;
2556  fail:
2557     *q = '\0';
2558     return -1;
2559 }
2560
2561 /**
2562  * Print  nice hexa dump of a buffer
2563  * @param f stream for output
2564  * @param buf buffer
2565  * @param size buffer size
2566  */
2567 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2568 {
2569     int len, i, j, c;
2570
2571     for(i=0;i<size;i+=16) {
2572         len = size - i;
2573         if (len > 16)
2574             len = 16;
2575         fprintf(f, "%08x ", i);
2576         for(j=0;j<16;j++) {
2577             if (j < len)
2578                 fprintf(f, " %02x", buf[i+j]);
2579             else
2580                 fprintf(f, "   ");
2581         }
2582         fprintf(f, " ");
2583         for(j=0;j<len;j++) {
2584             c = buf[i+j];
2585             if (c < ' ' || c > '~')
2586                 c = '.';
2587             fprintf(f, "%c", c);
2588         }
2589         fprintf(f, "\n");
2590     }
2591 }
2592
2593 /**
2594  * Print on 'f' a nice dump of a packet
2595  * @param f stream for output
2596  * @param pkt packet to dump
2597  * @param dump_payload true if the payload must be displayed too
2598  */
2599 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2600 {
2601     fprintf(f, "stream #%d:\n", pkt->stream_index);
2602     fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2603     fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2604     /* DTS is _always_ valid after av_read_frame() */
2605     fprintf(f, "  dts=");
2606     if (pkt->dts == AV_NOPTS_VALUE)
2607         fprintf(f, "N/A");
2608     else
2609         fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2610     /* PTS may be not known if B frames are present */
2611     fprintf(f, "  pts=");
2612     if (pkt->pts == AV_NOPTS_VALUE)
2613         fprintf(f, "N/A");
2614     else
2615         fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2616     fprintf(f, "\n");
2617     fprintf(f, "  size=%d\n", pkt->size);
2618     if (dump_payload)
2619         av_hex_dump(f, pkt->data, pkt->size);
2620 }
2621
2622 void url_split(char *proto, int proto_size,
2623                char *authorization, int authorization_size,
2624                char *hostname, int hostname_size,
2625                int *port_ptr,
2626                char *path, int path_size,
2627                const char *url)
2628 {
2629     const char *p;
2630     char *q;
2631     int port;
2632
2633     port = -1;
2634
2635     p = url;
2636     q = proto;
2637     while (*p != ':' && *p != '\0') {
2638         if ((q - proto) < proto_size - 1)
2639             *q++ = *p;
2640         p++;
2641     }
2642     if (proto_size > 0)
2643         *q = '\0';
2644     if (authorization_size > 0)
2645         authorization[0] = '\0';
2646     if (*p == '\0') {
2647         if (proto_size > 0)
2648             proto[0] = '\0';
2649         if (hostname_size > 0)
2650             hostname[0] = '\0';
2651         p = url;
2652     } else {
2653         char *at,*slash; // PETR: position of '@' character and '/' character
2654
2655         p++;
2656         if (*p == '/')
2657             p++;
2658         if (*p == '/')
2659             p++;
2660         at = strchr(p,'@'); // PETR: get the position of '@'
2661         slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2662         if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2663
2664         q = at ? authorization : hostname;  // PETR: if '@' exists starting with auth.
2665
2666          while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2667             if (*p == '@') {    // PETR: passed '@'
2668               if (authorization_size > 0)
2669                   *q = '\0';
2670               q = hostname;
2671               at = NULL;
2672             } else if (!at) {   // PETR: hostname
2673               if ((q - hostname) < hostname_size - 1)
2674                   *q++ = *p;
2675             } else {
2676               if ((q - authorization) < authorization_size - 1)
2677                 *q++ = *p;
2678             }
2679             p++;
2680         }
2681         if (hostname_size > 0)
2682             *q = '\0';
2683         if (*p == ':') {
2684             p++;
2685             port = strtoul(p, (char **)&p, 10);
2686         }
2687     }
2688     if (port_ptr)
2689         *port_ptr = port;
2690     pstrcpy(path, path_size, p);
2691 }
2692
2693 /**
2694  * Set the pts for a given stream
2695  * @param s stream 
2696  * @param pts_wrap_bits number of bits effectively used by the pts
2697  *        (used for wrap control, 33 is the value for MPEG) 
2698  * @param pts_num numerator to convert to seconds (MPEG: 1) 
2699  * @param pts_den denominator to convert to seconds (MPEG: 90000)
2700  */
2701 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2702                      int pts_num, int pts_den)
2703 {
2704     s->pts_wrap_bits = pts_wrap_bits;
2705     s->time_base.num = pts_num;
2706     s->time_base.den = pts_den;
2707 }
2708
2709 /* fraction handling */
2710
2711 /**
2712  * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2713  * as 0 <= num < den.
2714  *
2715  * @param f fractional number
2716  * @param val integer value
2717  * @param num must be >= 0
2718  * @param den must be >= 1 
2719  */
2720 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2721 {
2722     num += (den >> 1);
2723     if (num >= den) {
2724         val += num / den;
2725         num = num % den;
2726     }
2727     f->val = val;
2728     f->num = num;
2729     f->den = den;
2730 }
2731
2732 /* set f to (val + 0.5) */
2733 void av_frac_set(AVFrac *f, int64_t val)
2734 {
2735     f->val = val;
2736     f->num = f->den >> 1;
2737 }
2738
2739 /**
2740  * Fractionnal addition to f: f = f + (incr / f->den)
2741  *
2742  * @param f fractional number
2743  * @param incr increment, can be positive or negative
2744  */
2745 void av_frac_add(AVFrac *f, int64_t incr)
2746 {
2747     int64_t num, den;
2748
2749     num = f->num + incr;
2750     den = f->den;
2751     if (num < 0) {
2752         f->val += num / den;
2753         num = num % den;
2754         if (num < 0) {
2755             num += den;
2756             f->val--;
2757         }
2758     } else if (num >= den) {
2759         f->val += num / den;
2760         num = num % den;
2761     }
2762     f->num = num;
2763 }
2764
2765 /**
2766  * register a new image format
2767  * @param img_fmt Image format descriptor
2768  */
2769 void av_register_image_format(AVImageFormat *img_fmt)
2770 {
2771     AVImageFormat **p;
2772
2773     p = &first_image_format;
2774     while (*p != NULL) p = &(*p)->next;
2775     *p = img_fmt;
2776     img_fmt->next = NULL;
2777 }
2778
2779 /* guess image format */
2780 AVImageFormat *av_probe_image_format(AVProbeData *pd)
2781 {
2782     AVImageFormat *fmt1, *fmt;
2783     int score, score_max;
2784
2785     fmt = NULL;
2786     score_max = 0;
2787     for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2788         if (fmt1->img_probe) {
2789             score = fmt1->img_probe(pd);
2790             if (score > score_max) {
2791                 score_max = score;
2792                 fmt = fmt1;
2793             }
2794         }
2795     }
2796     return fmt;
2797 }
2798
2799 AVImageFormat *guess_image_format(const char *filename)
2800 {
2801     AVImageFormat *fmt1;
2802
2803     for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2804         if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2805             return fmt1;
2806     }
2807     return NULL;
2808 }
2809
2810 /**
2811  * Read an image from a stream. 
2812  * @param gb byte stream containing the image
2813  * @param fmt image format, NULL if probing is required
2814  */
2815 int av_read_image(ByteIOContext *pb, const char *filename,
2816                   AVImageFormat *fmt,
2817                   int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2818 {
2819     char buf[PROBE_BUF_SIZE];
2820     AVProbeData probe_data, *pd = &probe_data;
2821     offset_t pos;
2822     int ret;
2823
2824     if (!fmt) {
2825         pd->filename = filename;
2826         pd->buf = buf;
2827         pos = url_ftell(pb);
2828         pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2829         url_fseek(pb, pos, SEEK_SET);
2830         fmt = av_probe_image_format(pd);
2831     }
2832     if (!fmt)
2833         return AVERROR_NOFMT;
2834     ret = fmt->img_read(pb, alloc_cb, opaque);
2835     return ret;
2836 }
2837
2838 /**
2839  * Write an image to a stream.
2840  * @param pb byte stream for the image output
2841  * @param fmt image format
2842  * @param img image data and informations
2843  */
2844 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2845 {
2846     return fmt->img_write(pb, img);
2847 }
2848