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