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