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