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