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