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