f8a00f20dc440403599f74a642e6b1987625b618
[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
1238  * @param timestamp timestamp in AVStream.time_base units
1239  * @param flags flags which select direction and seeking mode
1240  * @return >= 0 on success
1241  */
1242 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1243 {
1244     int ret;
1245     AVStream *st;
1246     
1247     av_read_frame_flush(s);
1248     
1249     if(flags & AVSEEK_FLAG_BYTE)
1250         return av_seek_frame_byte(s, stream_index, timestamp, flags);
1251     
1252     if(stream_index < 0){
1253         stream_index= av_find_default_stream_index(s);
1254         if(stream_index < 0)
1255             return -1;
1256             
1257         st= s->streams[stream_index];
1258         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1259     }
1260     st= s->streams[stream_index];
1261
1262     /* first, we try the format specific seek */
1263     if (s->iformat->read_seek)
1264         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1265     else
1266         ret = -1;
1267     if (ret >= 0) {
1268         return 0;
1269     }
1270
1271     if(s->iformat->read_timestamp)
1272         return av_seek_frame_binary(s, stream_index, timestamp, flags);
1273     else
1274         return av_seek_frame_generic(s, stream_index, timestamp, flags);
1275 }
1276
1277 /*******************************************************/
1278
1279 /* return TRUE if the stream has accurate timings for at least one component */
1280 static int av_has_timings(AVFormatContext *ic)
1281 {
1282     int i;
1283     AVStream *st;
1284
1285     for(i = 0;i < ic->nb_streams; i++) {
1286         st = ic->streams[i];
1287         if (st->start_time != AV_NOPTS_VALUE &&
1288             st->duration != AV_NOPTS_VALUE)
1289             return 1;
1290     }
1291     return 0;
1292 }
1293
1294 /* estimate the stream timings from the one of each components. Also
1295    compute the global bitrate if possible */
1296 static void av_update_stream_timings(AVFormatContext *ic)
1297 {
1298     int64_t start_time, end_time, end_time1;
1299     int i;
1300     AVStream *st;
1301
1302     start_time = MAXINT64;
1303     end_time = MININT64;
1304     for(i = 0;i < ic->nb_streams; i++) {
1305         st = ic->streams[i];
1306         if (st->start_time != AV_NOPTS_VALUE) {
1307             if (st->start_time < start_time)
1308                 start_time = st->start_time;
1309             if (st->duration != AV_NOPTS_VALUE) {
1310                 end_time1 = st->start_time + st->duration;
1311                 if (end_time1 > end_time)
1312                     end_time = end_time1;
1313             }
1314         }
1315     }
1316     if (start_time != MAXINT64) {
1317         ic->start_time = start_time;
1318         if (end_time != MAXINT64) {
1319             ic->duration = end_time - start_time;
1320             if (ic->file_size > 0) {
1321                 /* compute the bit rate */
1322                 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE / 
1323                     (double)ic->duration;
1324             }
1325         }
1326     }
1327
1328 }
1329
1330 static void fill_all_stream_timings(AVFormatContext *ic)
1331 {
1332     int i;
1333     AVStream *st;
1334
1335     av_update_stream_timings(ic);
1336     for(i = 0;i < ic->nb_streams; i++) {
1337         st = ic->streams[i];
1338         if (st->start_time == AV_NOPTS_VALUE) {
1339             st->start_time = ic->start_time;
1340             st->duration = ic->duration;
1341         }
1342     }
1343 }
1344
1345 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1346 {
1347     int64_t filesize, duration;
1348     int bit_rate, i;
1349     AVStream *st;
1350
1351     /* if bit_rate is already set, we believe it */
1352     if (ic->bit_rate == 0) {
1353         bit_rate = 0;
1354         for(i=0;i<ic->nb_streams;i++) {
1355             st = ic->streams[i];
1356             bit_rate += st->codec.bit_rate;
1357         }
1358         ic->bit_rate = bit_rate;
1359     }
1360
1361     /* if duration is already set, we believe it */
1362     if (ic->duration == AV_NOPTS_VALUE && 
1363         ic->bit_rate != 0 && 
1364         ic->file_size != 0)  {
1365         filesize = ic->file_size;
1366         if (filesize > 0) {
1367             duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1368             for(i = 0; i < ic->nb_streams; i++) {
1369                 st = ic->streams[i];
1370                 if (st->start_time == AV_NOPTS_VALUE ||
1371                     st->duration == AV_NOPTS_VALUE) {
1372                     st->start_time = 0;
1373                     st->duration = duration;
1374                 }
1375             }
1376         }
1377     }
1378 }
1379
1380 #define DURATION_MAX_READ_SIZE 250000
1381
1382 /* only usable for MPEG-PS streams */
1383 static void av_estimate_timings_from_pts(AVFormatContext *ic)
1384 {
1385     AVPacket pkt1, *pkt = &pkt1;
1386     AVStream *st;
1387     int read_size, i, ret;
1388     int64_t start_time, end_time, end_time1;
1389     int64_t filesize, offset, duration;
1390     
1391     /* free previous packet */
1392     if (ic->cur_st && ic->cur_st->parser)
1393         av_free_packet(&ic->cur_pkt); 
1394     ic->cur_st = NULL;
1395
1396     /* flush packet queue */
1397     flush_packet_queue(ic);
1398
1399     for(i=0;i<ic->nb_streams;i++) {
1400         st = ic->streams[i];
1401         if (st->parser) {
1402             av_parser_close(st->parser);
1403             st->parser= NULL;
1404         }
1405     }
1406     
1407     /* we read the first packets to get the first PTS (not fully
1408        accurate, but it is enough now) */
1409     url_fseek(&ic->pb, 0, SEEK_SET);
1410     read_size = 0;
1411     for(;;) {
1412         if (read_size >= DURATION_MAX_READ_SIZE)
1413             break;
1414         /* if all info is available, we can stop */
1415         for(i = 0;i < ic->nb_streams; i++) {
1416             st = ic->streams[i];
1417             if (st->start_time == AV_NOPTS_VALUE)
1418                 break;
1419         }
1420         if (i == ic->nb_streams)
1421             break;
1422
1423         ret = av_read_packet(ic, pkt);
1424         if (ret != 0)
1425             break;
1426         read_size += pkt->size;
1427         st = ic->streams[pkt->stream_index];
1428         if (pkt->pts != AV_NOPTS_VALUE) {
1429             if (st->start_time == AV_NOPTS_VALUE)
1430                 st->start_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1431         }
1432         av_free_packet(pkt);
1433     }
1434
1435     /* we compute the minimum start_time and use it as default */
1436     start_time = MAXINT64;
1437     for(i = 0; i < ic->nb_streams; i++) {
1438         st = ic->streams[i];
1439         if (st->start_time != AV_NOPTS_VALUE &&
1440             st->start_time < start_time)
1441             start_time = st->start_time;
1442     }
1443     if (start_time != MAXINT64)
1444         ic->start_time = start_time;
1445     
1446     /* estimate the end time (duration) */
1447     /* XXX: may need to support wrapping */
1448     filesize = ic->file_size;
1449     offset = filesize - DURATION_MAX_READ_SIZE;
1450     if (offset < 0)
1451         offset = 0;
1452
1453     url_fseek(&ic->pb, offset, SEEK_SET);
1454     read_size = 0;
1455     for(;;) {
1456         if (read_size >= DURATION_MAX_READ_SIZE)
1457             break;
1458         /* if all info is available, we can stop */
1459         for(i = 0;i < ic->nb_streams; i++) {
1460             st = ic->streams[i];
1461             if (st->duration == AV_NOPTS_VALUE)
1462                 break;
1463         }
1464         if (i == ic->nb_streams)
1465             break;
1466         
1467         ret = av_read_packet(ic, pkt);
1468         if (ret != 0)
1469             break;
1470         read_size += pkt->size;
1471         st = ic->streams[pkt->stream_index];
1472         if (pkt->pts != AV_NOPTS_VALUE) {
1473             end_time = av_rescale(pkt->pts, st->time_base.num * (int64_t)AV_TIME_BASE, st->time_base.den);
1474             duration = end_time - st->start_time;
1475             if (duration > 0) {
1476                 if (st->duration == AV_NOPTS_VALUE ||
1477                     st->duration < duration)
1478                     st->duration = duration;
1479             }
1480         }
1481         av_free_packet(pkt);
1482     }
1483     
1484     /* estimate total duration */
1485     end_time = MININT64;
1486     for(i = 0;i < ic->nb_streams; i++) {
1487         st = ic->streams[i];
1488         if (st->duration != AV_NOPTS_VALUE) {
1489             end_time1 = st->start_time + st->duration;
1490             if (end_time1 > end_time)
1491                 end_time = end_time1;
1492         }
1493     }
1494     
1495     /* update start_time (new stream may have been created, so we do
1496        it at the end */
1497     if (ic->start_time != AV_NOPTS_VALUE) {
1498         for(i = 0; i < ic->nb_streams; i++) {
1499             st = ic->streams[i];
1500             if (st->start_time == AV_NOPTS_VALUE)
1501                 st->start_time = ic->start_time;
1502         }
1503     }
1504
1505     if (end_time != MININT64) {
1506         /* put dummy values for duration if needed */
1507         for(i = 0;i < ic->nb_streams; i++) {
1508             st = ic->streams[i];
1509             if (st->duration == AV_NOPTS_VALUE && 
1510                 st->start_time != AV_NOPTS_VALUE)
1511                 st->duration = end_time - st->start_time;
1512         }
1513         ic->duration = end_time - ic->start_time;
1514     }
1515
1516     url_fseek(&ic->pb, 0, SEEK_SET);
1517 }
1518
1519 static void av_estimate_timings(AVFormatContext *ic)
1520 {
1521     URLContext *h;
1522     int64_t file_size;
1523
1524     /* get the file size, if possible */
1525     if (ic->iformat->flags & AVFMT_NOFILE) {
1526         file_size = 0;
1527     } else {
1528         h = url_fileno(&ic->pb);
1529         file_size = url_filesize(h);
1530         if (file_size < 0)
1531             file_size = 0;
1532     }
1533     ic->file_size = file_size;
1534
1535     if (ic->iformat == &mpegps_demux) {
1536         /* get accurate estimate from the PTSes */
1537         av_estimate_timings_from_pts(ic);
1538     } else if (av_has_timings(ic)) {
1539         /* at least one components has timings - we use them for all
1540            the components */
1541         fill_all_stream_timings(ic);
1542     } else {
1543         /* less precise: use bit rate info */
1544         av_estimate_timings_from_bit_rate(ic);
1545     }
1546     av_update_stream_timings(ic);
1547
1548 #if 0
1549     {
1550         int i;
1551         AVStream *st;
1552         for(i = 0;i < ic->nb_streams; i++) {
1553             st = ic->streams[i];
1554         printf("%d: start_time: %0.3f duration: %0.3f\n", 
1555                i, (double)st->start_time / AV_TIME_BASE, 
1556                (double)st->duration / AV_TIME_BASE);
1557         }
1558         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n", 
1559                (double)ic->start_time / AV_TIME_BASE, 
1560                (double)ic->duration / AV_TIME_BASE,
1561                ic->bit_rate / 1000);
1562     }
1563 #endif
1564 }
1565
1566 static int has_codec_parameters(AVCodecContext *enc)
1567 {
1568     int val;
1569     switch(enc->codec_type) {
1570     case CODEC_TYPE_AUDIO:
1571         val = enc->sample_rate;
1572         break;
1573     case CODEC_TYPE_VIDEO:
1574         val = enc->width;
1575         break;
1576     default:
1577         val = 1;
1578         break;
1579     }
1580     return (val != 0);
1581 }
1582
1583 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1584 {
1585     int16_t *samples;
1586     AVCodec *codec;
1587     int got_picture, ret;
1588     AVFrame picture;
1589     
1590     codec = avcodec_find_decoder(st->codec.codec_id);
1591     if (!codec)
1592         return -1;
1593     ret = avcodec_open(&st->codec, codec);
1594     if (ret < 0)
1595         return ret;
1596     switch(st->codec.codec_type) {
1597     case CODEC_TYPE_VIDEO:
1598         ret = avcodec_decode_video(&st->codec, &picture, 
1599                                    &got_picture, (uint8_t *)data, size);
1600         break;
1601     case CODEC_TYPE_AUDIO:
1602         samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1603         if (!samples)
1604             goto fail;
1605         ret = avcodec_decode_audio(&st->codec, samples, 
1606                                    &got_picture, (uint8_t *)data, size);
1607         av_free(samples);
1608         break;
1609     default:
1610         break;
1611     }
1612  fail:
1613     avcodec_close(&st->codec);
1614     return ret;
1615 }
1616
1617 /* absolute maximum size we read until we abort */
1618 #define MAX_READ_SIZE        5000000
1619
1620 /* maximum duration until we stop analysing the stream */
1621 #define MAX_STREAM_DURATION  ((int)(AV_TIME_BASE * 1.0))
1622
1623 /**
1624  * Read the beginning of a media file to get stream information. This
1625  * is useful for file formats with no headers such as MPEG. This
1626  * function also compute the real frame rate in case of mpeg2 repeat
1627  * frame mode.
1628  *
1629  * @param ic media file handle
1630  * @return >=0 if OK. AVERROR_xxx if error.  
1631  */
1632 int av_find_stream_info(AVFormatContext *ic)
1633 {
1634     int i, count, ret, read_size;
1635     AVStream *st;
1636     AVPacket pkt1, *pkt;
1637     AVPacketList *pktl=NULL, **ppktl;
1638
1639     count = 0;
1640     read_size = 0;
1641     ppktl = &ic->packet_buffer;
1642     for(;;) {
1643         /* check if one codec still needs to be handled */
1644         for(i=0;i<ic->nb_streams;i++) {
1645             st = ic->streams[i];
1646             if (!has_codec_parameters(&st->codec))
1647                 break;
1648         }
1649         if (i == ic->nb_streams) {
1650             /* NOTE: if the format has no header, then we need to read
1651                some packets to get most of the streams, so we cannot
1652                stop here */
1653             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1654                 /* if we found the info for all the codecs, we can stop */
1655                 ret = count;
1656                 break;
1657             }
1658         } else {
1659             /* we did not get all the codec info, but we read too much data */
1660             if (read_size >= MAX_READ_SIZE) {
1661                 ret = count;
1662                 break;
1663             }
1664         }
1665
1666         /* NOTE: a new stream can be added there if no header in file
1667            (AVFMTCTX_NOHEADER) */
1668         ret = av_read_frame_internal(ic, &pkt1);
1669         if (ret < 0) {
1670             /* EOF or error */
1671             ret = -1; /* we could not have all the codec parameters before EOF */
1672             if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1673                 i == ic->nb_streams)
1674                 ret = 0;
1675             break;
1676         }
1677
1678         pktl = av_mallocz(sizeof(AVPacketList));
1679         if (!pktl) {
1680             ret = AVERROR_NOMEM;
1681             break;
1682         }
1683
1684         /* add the packet in the buffered packet list */
1685         *ppktl = pktl;
1686         ppktl = &pktl->next;
1687
1688         pkt = &pktl->pkt;
1689         *pkt = pkt1;
1690         
1691         /* duplicate the packet */
1692         if (av_dup_packet(pkt) < 0) {
1693                 ret = AVERROR_NOMEM;
1694                 break;
1695         }
1696
1697         read_size += pkt->size;
1698
1699         st = ic->streams[pkt->stream_index];
1700         st->codec_info_duration += pkt->duration;
1701         if (pkt->duration != 0)
1702             st->codec_info_nb_frames++;
1703
1704         /* if still no information, we try to open the codec and to
1705            decompress the frame. We try to avoid that in most cases as
1706            it takes longer and uses more memory. For MPEG4, we need to
1707            decompress for Quicktime. */
1708         if (!has_codec_parameters(&st->codec) &&
1709             (st->codec.codec_id == CODEC_ID_FLV1 ||
1710              st->codec.codec_id == CODEC_ID_H264 ||
1711              st->codec.codec_id == CODEC_ID_H263 ||
1712              st->codec.codec_id == CODEC_ID_VORBIS ||
1713              st->codec.codec_id == CODEC_ID_MJPEG ||
1714              (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1715             try_decode_frame(st, pkt->data, pkt->size);
1716         
1717         if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1718             break;
1719         }
1720         count++;
1721     }
1722
1723     /* set real frame rate info */
1724     for(i=0;i<ic->nb_streams;i++) {
1725         st = ic->streams[i];
1726         if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1727             /* compute the real frame rate for telecine */
1728             if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1729                  st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1730                 st->codec.sub_id == 2) {
1731                 if (st->codec_info_nb_frames >= 20) {
1732                     float coded_frame_rate, est_frame_rate;
1733                     est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) / 
1734                         (double)st->codec_info_duration ;
1735                     coded_frame_rate = (double)st->codec.frame_rate /
1736                         (double)st->codec.frame_rate_base;
1737 #if 0
1738                     printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n", 
1739                            coded_frame_rate, est_frame_rate);
1740 #endif
1741                     /* if we detect that it could be a telecine, we
1742                        signal it. It would be better to do it at a
1743                        higher level as it can change in a film */
1744                     if (coded_frame_rate >= 24.97 && 
1745                         (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1746                         st->r_frame_rate = 24024;
1747                         st->r_frame_rate_base = 1001;
1748                     }
1749                 }
1750             }
1751             /* if no real frame rate, use the codec one */
1752             if (!st->r_frame_rate){
1753                 st->r_frame_rate      = st->codec.frame_rate;
1754                 st->r_frame_rate_base = st->codec.frame_rate_base;
1755             }
1756         }
1757     }
1758
1759     av_estimate_timings(ic);
1760 #if 0
1761     /* correct DTS for b frame streams with no timestamps */
1762     for(i=0;i<ic->nb_streams;i++) {
1763         st = ic->streams[i];
1764         if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1765             if(b-frames){
1766                 ppktl = &ic->packet_buffer;
1767                 while(ppkt1){
1768                     if(ppkt1->stream_index != i)
1769                         continue;
1770                     if(ppkt1->pkt->dts < 0)
1771                         break;
1772                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1773                         break;
1774                     ppkt1->pkt->dts -= delta;
1775                     ppkt1= ppkt1->next;
1776                 }
1777                 if(ppkt1)
1778                     continue;
1779                 st->cur_dts -= delta;
1780             }
1781         }
1782     }
1783 #endif
1784     return ret;
1785 }
1786
1787 /*******************************************************/
1788
1789 /**
1790  * start playing a network based stream (e.g. RTSP stream) at the
1791  * current position 
1792  */
1793 int av_read_play(AVFormatContext *s)
1794 {
1795     if (!s->iformat->read_play)
1796         return AVERROR_NOTSUPP;
1797     return s->iformat->read_play(s);
1798 }
1799
1800 /**
1801  * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1802  * to resume it.
1803  */
1804 int av_read_pause(AVFormatContext *s)
1805 {
1806     if (!s->iformat->read_pause)
1807         return AVERROR_NOTSUPP;
1808     return s->iformat->read_pause(s);
1809 }
1810
1811 /**
1812  * Close a media file (but not its codecs)
1813  *
1814  * @param s media file handle
1815  */
1816 void av_close_input_file(AVFormatContext *s)
1817 {
1818     int i, must_open_file;
1819     AVStream *st;
1820
1821     /* free previous packet */
1822     if (s->cur_st && s->cur_st->parser)
1823         av_free_packet(&s->cur_pkt); 
1824
1825     if (s->iformat->read_close)
1826         s->iformat->read_close(s);
1827     for(i=0;i<s->nb_streams;i++) {
1828         /* free all data in a stream component */
1829         st = s->streams[i];
1830         if (st->parser) {
1831             av_parser_close(st->parser);
1832         }
1833         av_free(st->index_entries);
1834         av_free(st);
1835     }
1836     flush_packet_queue(s);
1837     must_open_file = 1;
1838     if (s->iformat->flags & AVFMT_NOFILE) {
1839         must_open_file = 0;
1840     }
1841     if (must_open_file) {
1842         url_fclose(&s->pb);
1843     }
1844     av_freep(&s->priv_data);
1845     av_free(s);
1846 }
1847
1848 /**
1849  * Add a new stream to a media file. Can only be called in the
1850  * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1851  * format context, then new streams can be added in read_packet too.
1852  *
1853  *
1854  * @param s media file handle
1855  * @param id file format dependent stream id 
1856  */
1857 AVStream *av_new_stream(AVFormatContext *s, int id)
1858 {
1859     AVStream *st;
1860
1861     if (s->nb_streams >= MAX_STREAMS)
1862         return NULL;
1863
1864     st = av_mallocz(sizeof(AVStream));
1865     if (!st)
1866         return NULL;
1867     avcodec_get_context_defaults(&st->codec);
1868     if (s->iformat) {
1869         /* no default bitrate if decoding */
1870         st->codec.bit_rate = 0;
1871     }
1872     st->index = s->nb_streams;
1873     st->id = id;
1874     st->start_time = AV_NOPTS_VALUE;
1875     st->duration = AV_NOPTS_VALUE;
1876     st->cur_dts = AV_NOPTS_VALUE;
1877
1878     /* default pts settings is MPEG like */
1879     av_set_pts_info(st, 33, 1, 90000);
1880     st->last_IP_pts = AV_NOPTS_VALUE;
1881
1882     s->streams[s->nb_streams++] = st;
1883     return st;
1884 }
1885
1886 /************************************************************/
1887 /* output media file */
1888
1889 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1890 {
1891     int ret;
1892     
1893     if (s->oformat->priv_data_size > 0) {
1894         s->priv_data = av_mallocz(s->oformat->priv_data_size);
1895         if (!s->priv_data)
1896             return AVERROR_NOMEM;
1897     } else
1898         s->priv_data = NULL;
1899         
1900     if (s->oformat->set_parameters) {
1901         ret = s->oformat->set_parameters(s, ap);
1902         if (ret < 0)
1903             return ret;
1904     }
1905     return 0;
1906 }
1907
1908 /**
1909  * allocate the stream private data and write the stream header to an
1910  * output media file
1911  *
1912  * @param s media file handle
1913  * @return 0 if OK. AVERROR_xxx if error.  
1914  */
1915 int av_write_header(AVFormatContext *s)
1916 {
1917     int ret, i;
1918     AVStream *st;
1919
1920     ret = s->oformat->write_header(s);
1921     if (ret < 0)
1922         return ret;
1923
1924     /* init PTS generation */
1925     for(i=0;i<s->nb_streams;i++) {
1926         st = s->streams[i];
1927
1928         switch (st->codec.codec_type) {
1929         case CODEC_TYPE_AUDIO:
1930             av_frac_init(&st->pts, 0, 0, 
1931                          (int64_t)st->time_base.num * st->codec.sample_rate);
1932             break;
1933         case CODEC_TYPE_VIDEO:
1934             av_frac_init(&st->pts, 0, 0, 
1935                          (int64_t)st->time_base.num * st->codec.frame_rate);
1936             break;
1937         default:
1938             break;
1939         }
1940     }
1941     return 0;
1942 }
1943
1944 //FIXME merge with compute_pkt_fields
1945 static void compute_pkt_fields2(AVStream *st, AVPacket *pkt){
1946     int b_frames = FFMAX(st->codec.has_b_frames, st->codec.max_b_frames);
1947     int num, den, frame_size;
1948
1949 //    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);
1950     
1951 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
1952         return -1;*/
1953             
1954     if(pkt->pts != AV_NOPTS_VALUE)
1955         pkt->pts = av_rescale(pkt->pts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1956     if(pkt->dts != AV_NOPTS_VALUE)
1957         pkt->dts = av_rescale(pkt->dts, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1958
1959     /* duration field */
1960     pkt->duration = av_rescale(pkt->duration, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1961     if (pkt->duration == 0) {
1962         compute_frame_duration(&num, &den, st, NULL, pkt);
1963         if (den && num) {
1964             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
1965         }
1966     }
1967
1968     //XXX/FIXME this is a temporary hack until all encoders output pts
1969     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !b_frames){
1970         pkt->dts=
1971 //        pkt->pts= st->cur_dts;
1972         pkt->pts= st->pts.val;
1973     }
1974
1975     //calculate dts from pts    
1976     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
1977         if(b_frames){
1978             if(st->last_IP_pts == AV_NOPTS_VALUE){
1979                 st->last_IP_pts= -pkt->duration;
1980             }
1981             if(st->last_IP_pts < pkt->pts){
1982                 pkt->dts= st->last_IP_pts;
1983                 st->last_IP_pts= pkt->pts;
1984             }else
1985                 pkt->dts= pkt->pts;
1986         }else
1987             pkt->dts= pkt->pts;
1988     }
1989     
1990 //    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%lld dts2:%lld\n", pkt->pts, pkt->dts);
1991     st->cur_dts= pkt->dts;
1992     st->pts.val= pkt->dts;
1993
1994     /* update pts */
1995     switch (st->codec.codec_type) {
1996     case CODEC_TYPE_AUDIO:
1997         frame_size = get_audio_frame_size(&st->codec, pkt->size);
1998
1999         /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2000            but it would be better if we had the real timestamps from the encoder */
2001         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2002             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2003         }
2004         break;
2005     case CODEC_TYPE_VIDEO:
2006         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec.frame_rate_base);
2007         break;
2008     default:
2009         break;
2010     }
2011 }
2012
2013 static void truncate_ts(AVStream *st, AVPacket *pkt){
2014     int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2015     
2016 //    if(pkt->dts < 0)
2017 //        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2018     
2019     pkt->pts &= pts_mask;
2020     pkt->dts &= pts_mask;
2021 }
2022
2023 /**
2024  * Write a packet to an output media file. The packet shall contain
2025  * one audio or video frame.
2026  *
2027  * @param s media file handle
2028  * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2029  * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2030  */
2031 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2032 {
2033     int ret;
2034
2035     compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2036     
2037     truncate_ts(s->streams[pkt->stream_index], pkt);
2038
2039     ret= s->oformat->write_packet(s, pkt);
2040     if(!ret)
2041         ret= url_ferror(&s->pb);
2042     return ret;
2043 }
2044
2045 /**
2046  * interleave_packet implementation which will interleave per DTS.
2047  */
2048 static int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2049     AVPacketList *pktl, **next_point, *this_pktl;
2050     int stream_count=0;
2051     int streams[MAX_STREAMS];
2052
2053     if(pkt){
2054         AVStream *st= s->streams[ pkt->stream_index];
2055
2056         assert(pkt->destruct != av_destruct_packet); //FIXME
2057
2058         this_pktl = av_mallocz(sizeof(AVPacketList));
2059         this_pktl->pkt= *pkt;
2060         av_dup_packet(&this_pktl->pkt);
2061
2062         next_point = &s->packet_buffer;
2063         while(*next_point){
2064             AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2065             int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2066             int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2067             if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2068                 break;
2069             next_point= &(*next_point)->next;
2070         }
2071         this_pktl->next= *next_point;
2072         *next_point= this_pktl;
2073     }
2074     
2075     memset(streams, 0, sizeof(streams));
2076     pktl= s->packet_buffer;
2077     while(pktl){
2078 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
2079         if(streams[ pktl->pkt.stream_index ] == 0)
2080             stream_count++;
2081         streams[ pktl->pkt.stream_index ]++;
2082         pktl= pktl->next;
2083     }
2084     
2085     if(s->nb_streams == stream_count || (flush && stream_count)){
2086         pktl= s->packet_buffer;
2087         *out= pktl->pkt;
2088         
2089         s->packet_buffer= pktl->next;        
2090         av_freep(&pktl);
2091         return 1;
2092     }else{
2093         av_init_packet(out);
2094         return 0;
2095     }
2096 }
2097
2098 /**
2099  * Interleaves a AVPacket correctly so it can be muxed.
2100  * @param out the interleaved packet will be output here
2101  * @param in the input packet
2102  * @param flush 1 if no further packets are available as input and all
2103  *              remaining packets should be output
2104  * @return 1 if a packet was output, 0 if no packet could be output, 
2105  *         < 0 if an error occured
2106  */
2107 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2108     if(s->oformat->interleave_packet)
2109         return s->oformat->interleave_packet(s, out, in, flush);
2110     else
2111         return av_interleave_packet_per_dts(s, out, in, flush);
2112 }
2113
2114 /**
2115  * Writes a packet to an output media file ensuring correct interleaving. 
2116  * The packet shall contain one audio or video frame.
2117  * If the packets are already correctly interleaved the application should
2118  * call av_write_frame() instead as its slightly faster, its also important
2119  * to keep in mind that completly non interleaved input will need huge amounts
2120  * of memory to interleave with this, so its prefereable to interleave at the
2121  * demuxer level
2122  *
2123  * @param s media file handle
2124  * @param pkt the packet, which contains the stream_index, buf/buf_size, dts/pts, ...
2125  * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
2126  */
2127 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2128     AVStream *st= s->streams[ pkt->stream_index];
2129
2130     compute_pkt_fields2(st, pkt);
2131     
2132     //FIXME/XXX/HACK drop zero sized packets
2133     if(st->codec.codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2134         return 0;
2135     
2136     if(pkt->dts == AV_NOPTS_VALUE)
2137         return -1;
2138
2139     for(;;){
2140         AVPacket opkt;
2141         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2142         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2143             return ret;
2144         
2145         truncate_ts(s->streams[opkt.stream_index], &opkt);
2146         ret= s->oformat->write_packet(s, &opkt);
2147         
2148         av_free_packet(&opkt);
2149         pkt= NULL;
2150         
2151         if(ret<0)
2152             return ret;
2153         if(url_ferror(&s->pb))
2154             return url_ferror(&s->pb);
2155     }
2156 }
2157
2158 /**
2159  * write the stream trailer to an output media file and and free the
2160  * file private data.
2161  *
2162  * @param s media file handle
2163  * @return 0 if OK. AVERROR_xxx if error.  */
2164 int av_write_trailer(AVFormatContext *s)
2165 {
2166     int ret, i;
2167     
2168     for(;;){
2169         AVPacket pkt;
2170         ret= av_interleave_packet(s, &pkt, NULL, 1);
2171         if(ret<0) //FIXME cleanup needed for ret<0 ?
2172             goto fail;
2173         if(!ret)
2174             break;
2175         
2176         truncate_ts(s->streams[pkt.stream_index], &pkt);
2177         ret= s->oformat->write_packet(s, &pkt);
2178         
2179         av_free_packet(&pkt);
2180         
2181         if(ret<0)
2182             goto fail;
2183         if(url_ferror(&s->pb))
2184             goto fail;
2185     }
2186
2187     ret = s->oformat->write_trailer(s);
2188 fail:
2189     if(ret == 0)
2190        ret=url_ferror(&s->pb);
2191     for(i=0;i<s->nb_streams;i++)
2192         av_freep(&s->streams[i]->priv_data);
2193     av_freep(&s->priv_data);
2194     return ret;
2195 }
2196
2197 /* "user interface" functions */
2198
2199 void dump_format(AVFormatContext *ic,
2200                  int index, 
2201                  const char *url,
2202                  int is_output)
2203 {
2204     int i, flags;
2205     char buf[256];
2206
2207     av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n", 
2208             is_output ? "Output" : "Input",
2209             index, 
2210             is_output ? ic->oformat->name : ic->iformat->name, 
2211             is_output ? "to" : "from", url);
2212     if (!is_output) {
2213         av_log(NULL, AV_LOG_DEBUG, "  Duration: ");
2214         if (ic->duration != AV_NOPTS_VALUE) {
2215             int hours, mins, secs, us;
2216             secs = ic->duration / AV_TIME_BASE;
2217             us = ic->duration % AV_TIME_BASE;
2218             mins = secs / 60;
2219             secs %= 60;
2220             hours = mins / 60;
2221             mins %= 60;
2222             av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs, 
2223                    (10 * us) / AV_TIME_BASE);
2224         } else {
2225             av_log(NULL, AV_LOG_DEBUG, "N/A");
2226         }
2227         if (ic->start_time != AV_NOPTS_VALUE) {
2228             int secs, us;
2229             av_log(NULL, AV_LOG_DEBUG, ", start: ");
2230             secs = ic->start_time / AV_TIME_BASE;
2231             us = ic->start_time % AV_TIME_BASE;
2232             av_log(NULL, AV_LOG_DEBUG, "%d.%06d",
2233                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2234         }
2235         av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
2236         if (ic->bit_rate) {
2237             av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
2238         } else {
2239             av_log(NULL, AV_LOG_DEBUG, "N/A");
2240         }
2241         av_log(NULL, AV_LOG_DEBUG, "\n");
2242     }
2243     for(i=0;i<ic->nb_streams;i++) {
2244         AVStream *st = ic->streams[i];
2245         avcodec_string(buf, sizeof(buf), &st->codec, is_output);
2246         av_log(NULL, AV_LOG_DEBUG, "  Stream #%d.%d", index, i);
2247         /* the pid is an important information, so we display it */
2248         /* XXX: add a generic system */
2249         if (is_output)
2250             flags = ic->oformat->flags;
2251         else
2252             flags = ic->iformat->flags;
2253         if (flags & AVFMT_SHOW_IDS) {
2254             av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
2255         }
2256         av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
2257     }
2258 }
2259
2260 typedef struct {
2261     const char *abv;
2262     int width, height;
2263     int frame_rate, frame_rate_base;
2264 } AbvEntry;
2265
2266 static AbvEntry frame_abvs[] = {
2267     { "ntsc",      720, 480, 30000, 1001 },
2268     { "pal",       720, 576,    25,    1 },
2269     { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2270     { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2271     { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2272     { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2273     { "film",      352, 240,    24,    1 },
2274     { "ntsc-film", 352, 240, 24000, 1001 },
2275     { "sqcif",     128,  96,     0,    0 },
2276     { "qcif",      176, 144,     0,    0 },
2277     { "cif",       352, 288,     0,    0 },
2278     { "4cif",      704, 576,     0,    0 },
2279 };
2280
2281 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2282 {
2283     int i;
2284     int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2285     const char *p;
2286     int frame_width = 0, frame_height = 0;
2287
2288     for(i=0;i<n;i++) {
2289         if (!strcmp(frame_abvs[i].abv, str)) {
2290             frame_width = frame_abvs[i].width;
2291             frame_height = frame_abvs[i].height;
2292             break;
2293         }
2294     }
2295     if (i == n) {
2296         p = str;
2297         frame_width = strtol(p, (char **)&p, 10);
2298         if (*p)
2299             p++;
2300         frame_height = strtol(p, (char **)&p, 10);
2301     }
2302     if (frame_width <= 0 || frame_height <= 0)
2303         return -1;
2304     *width_ptr = frame_width;
2305     *height_ptr = frame_height;
2306     return 0;
2307 }
2308
2309 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2310 {
2311     int i;
2312     char* cp;
2313    
2314     /* First, we check our abbreviation table */
2315     for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2316          if (!strcmp(frame_abvs[i].abv, arg)) {
2317              *frame_rate = frame_abvs[i].frame_rate;
2318              *frame_rate_base = frame_abvs[i].frame_rate_base;
2319              return 0;
2320          }
2321
2322     /* Then, we try to parse it as fraction */
2323     cp = strchr(arg, '/');
2324     if (cp) {
2325         char* cpp;
2326         *frame_rate = strtol(arg, &cpp, 10);
2327         if (cpp != arg || cpp == cp) 
2328             *frame_rate_base = strtol(cp+1, &cpp, 10);
2329         else
2330            *frame_rate = 0;
2331     } 
2332     else {
2333         /* Finally we give up and parse it as double */
2334         *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
2335         *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
2336     }
2337     if (!*frame_rate || !*frame_rate_base)
2338         return -1;
2339     else
2340         return 0;
2341 }
2342
2343 /* Syntax:
2344  * - If not a duration:
2345  *  [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
2346  * Time is localtime unless Z is suffixed to the end. In this case GMT
2347  * Return the date in micro seconds since 1970 
2348  * - If duration:
2349  *  HH[:MM[:SS[.m...]]]
2350  *  S+[.m...]
2351  */
2352 int64_t parse_date(const char *datestr, int duration)
2353 {
2354     const char *p;
2355     int64_t t;
2356     struct tm dt;
2357     int i;
2358     static const char *date_fmt[] = {
2359         "%Y-%m-%d",
2360         "%Y%m%d",
2361     };
2362     static const char *time_fmt[] = {
2363         "%H:%M:%S",
2364         "%H%M%S",
2365     };
2366     const char *q;
2367     int is_utc, len;
2368     char lastch;
2369     int negative = 0;
2370
2371 #undef time
2372     time_t now = time(0);
2373
2374     len = strlen(datestr);
2375     if (len > 0)
2376         lastch = datestr[len - 1];
2377     else
2378         lastch = '\0';
2379     is_utc = (lastch == 'z' || lastch == 'Z');
2380
2381     memset(&dt, 0, sizeof(dt));
2382
2383     p = datestr;
2384     q = NULL;
2385     if (!duration) {
2386         for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2387             q = small_strptime(p, date_fmt[i], &dt);
2388             if (q) {
2389                 break;
2390             }
2391         }
2392
2393         if (!q) {
2394             if (is_utc) {
2395                 dt = *gmtime(&now);
2396             } else {
2397                 dt = *localtime(&now);
2398             }
2399             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2400         } else {
2401             p = q;
2402         }
2403
2404         if (*p == 'T' || *p == 't' || *p == ' ')
2405             p++;
2406
2407         for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2408             q = small_strptime(p, time_fmt[i], &dt);
2409             if (q) {
2410                 break;
2411             }
2412         }
2413     } else {
2414         if (p[0] == '-') {
2415             negative = 1;
2416             ++p;
2417         }
2418         q = small_strptime(p, time_fmt[0], &dt);
2419         if (!q) {
2420             dt.tm_sec = strtol(p, (char **)&q, 10);
2421             dt.tm_min = 0;
2422             dt.tm_hour = 0;
2423         }
2424     }
2425
2426     /* Now we have all the fields that we can get */
2427     if (!q) {
2428         if (duration)
2429             return 0;
2430         else
2431             return now * int64_t_C(1000000);
2432     }
2433
2434     if (duration) {
2435         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2436     } else {
2437         dt.tm_isdst = -1;       /* unknown */
2438         if (is_utc) {
2439             t = mktimegm(&dt);
2440         } else {
2441             t = mktime(&dt);
2442         }
2443     }
2444
2445     t *= 1000000;
2446
2447     if (*q == '.') {
2448         int val, n;
2449         q++;
2450         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2451             if (!isdigit(*q)) 
2452                 break;
2453             val += n * (*q - '0');
2454         }
2455         t += val;
2456     }
2457     return negative ? -t : t;
2458 }
2459
2460 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
2461    1 if found */
2462 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2463 {
2464     const char *p;
2465     char tag[128], *q;
2466
2467     p = info;
2468     if (*p == '?')
2469         p++;
2470     for(;;) {
2471         q = tag;
2472         while (*p != '\0' && *p != '=' && *p != '&') {
2473             if ((q - tag) < sizeof(tag) - 1)
2474                 *q++ = *p;
2475             p++;
2476         }
2477         *q = '\0';
2478         q = arg;
2479         if (*p == '=') {
2480             p++;
2481             while (*p != '&' && *p != '\0') {
2482                 if ((q - arg) < arg_size - 1) {
2483                     if (*p == '+')
2484                         *q++ = ' ';
2485                     else
2486                         *q++ = *p;
2487                 }
2488                 p++;
2489             }
2490             *q = '\0';
2491         }
2492         if (!strcmp(tag, tag1)) 
2493             return 1;
2494         if (*p != '&')
2495             break;
2496         p++;
2497     }
2498     return 0;
2499 }
2500
2501 /* Return in 'buf' the path with '%d' replaced by number. Also handles
2502    the '%0nd' format where 'n' is the total number of digits and
2503    '%%'. Return 0 if OK, and -1 if format error */
2504 int get_frame_filename(char *buf, int buf_size,
2505                        const char *path, int number)
2506 {
2507     const char *p;
2508     char *q, buf1[20], c;
2509     int nd, len, percentd_found;
2510
2511     q = buf;
2512     p = path;
2513     percentd_found = 0;
2514     for(;;) {
2515         c = *p++;
2516         if (c == '\0')
2517             break;
2518         if (c == '%') {
2519             do {
2520                 nd = 0;
2521                 while (isdigit(*p)) {
2522                     nd = nd * 10 + *p++ - '0';
2523                 }
2524                 c = *p++;
2525             } while (isdigit(c));
2526
2527             switch(c) {
2528             case '%':
2529                 goto addchar;
2530             case 'd':
2531                 if (percentd_found)
2532                     goto fail;
2533                 percentd_found = 1;
2534                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2535                 len = strlen(buf1);
2536                 if ((q - buf + len) > buf_size - 1)
2537                     goto fail;
2538                 memcpy(q, buf1, len);
2539                 q += len;
2540                 break;
2541             default:
2542                 goto fail;
2543             }
2544         } else {
2545         addchar:
2546             if ((q - buf) < buf_size - 1)
2547                 *q++ = c;
2548         }
2549     }
2550     if (!percentd_found)
2551         goto fail;
2552     *q = '\0';
2553     return 0;
2554  fail:
2555     *q = '\0';
2556     return -1;
2557 }
2558
2559 /**
2560  * Print  nice hexa dump of a buffer
2561  * @param f stream for output
2562  * @param buf buffer
2563  * @param size buffer size
2564  */
2565 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2566 {
2567     int len, i, j, c;
2568
2569     for(i=0;i<size;i+=16) {
2570         len = size - i;
2571         if (len > 16)
2572             len = 16;
2573         fprintf(f, "%08x ", i);
2574         for(j=0;j<16;j++) {
2575             if (j < len)
2576                 fprintf(f, " %02x", buf[i+j]);
2577             else
2578                 fprintf(f, "   ");
2579         }
2580         fprintf(f, " ");
2581         for(j=0;j<len;j++) {
2582             c = buf[i+j];
2583             if (c < ' ' || c > '~')
2584                 c = '.';
2585             fprintf(f, "%c", c);
2586         }
2587         fprintf(f, "\n");
2588     }
2589 }
2590
2591 /**
2592  * Print on 'f' a nice dump of a packet
2593  * @param f stream for output
2594  * @param pkt packet to dump
2595  * @param dump_payload true if the payload must be displayed too
2596  */
2597 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2598 {
2599     fprintf(f, "stream #%d:\n", pkt->stream_index);
2600     fprintf(f, "  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2601     fprintf(f, "  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2602     /* DTS is _always_ valid after av_read_frame() */
2603     fprintf(f, "  dts=");
2604     if (pkt->dts == AV_NOPTS_VALUE)
2605         fprintf(f, "N/A");
2606     else
2607         fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2608     /* PTS may be not known if B frames are present */
2609     fprintf(f, "  pts=");
2610     if (pkt->pts == AV_NOPTS_VALUE)
2611         fprintf(f, "N/A");
2612     else
2613         fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2614     fprintf(f, "\n");
2615     fprintf(f, "  size=%d\n", pkt->size);
2616     if (dump_payload)
2617         av_hex_dump(f, pkt->data, pkt->size);
2618 }
2619
2620 void url_split(char *proto, int proto_size,
2621                char *authorization, int authorization_size,
2622                char *hostname, int hostname_size,
2623                int *port_ptr,
2624                char *path, int path_size,
2625                const char *url)
2626 {
2627     const char *p;
2628     char *q;
2629     int port;
2630
2631     port = -1;
2632
2633     p = url;
2634     q = proto;
2635     while (*p != ':' && *p != '\0') {
2636         if ((q - proto) < proto_size - 1)
2637             *q++ = *p;
2638         p++;
2639     }
2640     if (proto_size > 0)
2641         *q = '\0';
2642     if (authorization_size > 0)
2643         authorization[0] = '\0';
2644     if (*p == '\0') {
2645         if (proto_size > 0)
2646             proto[0] = '\0';
2647         if (hostname_size > 0)
2648             hostname[0] = '\0';
2649         p = url;
2650     } else {
2651         char *at,*slash; // PETR: position of '@' character and '/' character
2652
2653         p++;
2654         if (*p == '/')
2655             p++;
2656         if (*p == '/')
2657             p++;
2658         at = strchr(p,'@'); // PETR: get the position of '@'
2659         slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2660         if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2661
2662         q = at ? authorization : hostname;  // PETR: if '@' exists starting with auth.
2663
2664          while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2665             if (*p == '@') {    // PETR: passed '@'
2666               if (authorization_size > 0)
2667                   *q = '\0';
2668               q = hostname;
2669               at = NULL;
2670             } else if (!at) {   // PETR: hostname
2671               if ((q - hostname) < hostname_size - 1)
2672                   *q++ = *p;
2673             } else {
2674               if ((q - authorization) < authorization_size - 1)
2675                 *q++ = *p;
2676             }
2677             p++;
2678         }
2679         if (hostname_size > 0)
2680             *q = '\0';
2681         if (*p == ':') {
2682             p++;
2683             port = strtoul(p, (char **)&p, 10);
2684         }
2685     }
2686     if (port_ptr)
2687         *port_ptr = port;
2688     pstrcpy(path, path_size, p);
2689 }
2690
2691 /**
2692  * Set the pts for a given stream
2693  * @param s stream 
2694  * @param pts_wrap_bits number of bits effectively used by the pts
2695  *        (used for wrap control, 33 is the value for MPEG) 
2696  * @param pts_num numerator to convert to seconds (MPEG: 1) 
2697  * @param pts_den denominator to convert to seconds (MPEG: 90000)
2698  */
2699 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2700                      int pts_num, int pts_den)
2701 {
2702     s->pts_wrap_bits = pts_wrap_bits;
2703     s->time_base.num = pts_num;
2704     s->time_base.den = pts_den;
2705 }
2706
2707 /* fraction handling */
2708
2709 /**
2710  * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2711  * as 0 <= num < den.
2712  *
2713  * @param f fractional number
2714  * @param val integer value
2715  * @param num must be >= 0
2716  * @param den must be >= 1 
2717  */
2718 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2719 {
2720     num += (den >> 1);
2721     if (num >= den) {
2722         val += num / den;
2723         num = num % den;
2724     }
2725     f->val = val;
2726     f->num = num;
2727     f->den = den;
2728 }
2729
2730 /* set f to (val + 0.5) */
2731 void av_frac_set(AVFrac *f, int64_t val)
2732 {
2733     f->val = val;
2734     f->num = f->den >> 1;
2735 }
2736
2737 /**
2738  * Fractionnal addition to f: f = f + (incr / f->den)
2739  *
2740  * @param f fractional number
2741  * @param incr increment, can be positive or negative
2742  */
2743 void av_frac_add(AVFrac *f, int64_t incr)
2744 {
2745     int64_t num, den;
2746
2747     num = f->num + incr;
2748     den = f->den;
2749     if (num < 0) {
2750         f->val += num / den;
2751         num = num % den;
2752         if (num < 0) {
2753             num += den;
2754             f->val--;
2755         }
2756     } else if (num >= den) {
2757         f->val += num / den;
2758         num = num % den;
2759     }
2760     f->num = num;
2761 }
2762
2763 /**
2764  * register a new image format
2765  * @param img_fmt Image format descriptor
2766  */
2767 void av_register_image_format(AVImageFormat *img_fmt)
2768 {
2769     AVImageFormat **p;
2770
2771     p = &first_image_format;
2772     while (*p != NULL) p = &(*p)->next;
2773     *p = img_fmt;
2774     img_fmt->next = NULL;
2775 }
2776
2777 /* guess image format */
2778 AVImageFormat *av_probe_image_format(AVProbeData *pd)
2779 {
2780     AVImageFormat *fmt1, *fmt;
2781     int score, score_max;
2782
2783     fmt = NULL;
2784     score_max = 0;
2785     for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2786         if (fmt1->img_probe) {
2787             score = fmt1->img_probe(pd);
2788             if (score > score_max) {
2789                 score_max = score;
2790                 fmt = fmt1;
2791             }
2792         }
2793     }
2794     return fmt;
2795 }
2796
2797 AVImageFormat *guess_image_format(const char *filename)
2798 {
2799     AVImageFormat *fmt1;
2800
2801     for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2802         if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2803             return fmt1;
2804     }
2805     return NULL;
2806 }
2807
2808 /**
2809  * Read an image from a stream. 
2810  * @param gb byte stream containing the image
2811  * @param fmt image format, NULL if probing is required
2812  */
2813 int av_read_image(ByteIOContext *pb, const char *filename,
2814                   AVImageFormat *fmt,
2815                   int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2816 {
2817     char buf[PROBE_BUF_SIZE];
2818     AVProbeData probe_data, *pd = &probe_data;
2819     offset_t pos;
2820     int ret;
2821
2822     if (!fmt) {
2823         pd->filename = filename;
2824         pd->buf = buf;
2825         pos = url_ftell(pb);
2826         pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2827         url_fseek(pb, pos, SEEK_SET);
2828         fmt = av_probe_image_format(pd);
2829     }
2830     if (!fmt)
2831         return AVERROR_NOFMT;
2832     ret = fmt->img_read(pb, alloc_cb, opaque);
2833     return ret;
2834 }
2835
2836 /**
2837  * Write an image to a stream.
2838  * @param pb byte stream for the image output
2839  * @param fmt image format
2840  * @param img image data and informations
2841  */
2842 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2843 {
2844     return fmt->img_write(pb, img);
2845 }
2846