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