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