init packet before calling the demuxer
[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         assert(ts != AV_NOPTS_VALUE);
1221         if (target_ts <= ts) {
1222             pos_limit = start_pos - 1;
1223             pos_max = pos;
1224             ts_max = ts;
1225         }
1226         if (target_ts >= ts) {
1227             pos_min = pos;
1228             ts_min = ts;
1229         }
1230     }
1231
1232     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1233     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1234 #ifdef DEBUG_SEEK
1235     pos_min = pos;
1236     ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1237     pos_min++;
1238     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1239     av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1240            pos, ts_min, target_ts, ts_max);
1241 #endif
1242     *ts_ret= ts;
1243     return pos;
1244 }
1245
1246 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1247     int64_t pos_min, pos_max;
1248 #if 0
1249     AVStream *st;
1250
1251     if (stream_index < 0)
1252         return -1;
1253
1254     st= s->streams[stream_index];
1255 #endif
1256
1257     pos_min = s->data_offset;
1258     pos_max = url_fsize(&s->pb) - 1;
1259
1260     if     (pos < pos_min) pos= pos_min;
1261     else if(pos > pos_max) pos= pos_max;
1262
1263     url_fseek(&s->pb, pos, SEEK_SET);
1264
1265 #if 0
1266     av_update_cur_dts(s, st, ts);
1267 #endif
1268     return 0;
1269 }
1270
1271 static int av_seek_frame_generic(AVFormatContext *s,
1272                                  int stream_index, int64_t timestamp, int flags)
1273 {
1274     int index;
1275     AVStream *st;
1276     AVIndexEntry *ie;
1277
1278     st = s->streams[stream_index];
1279
1280     index = av_index_search_timestamp(st, timestamp, flags);
1281
1282     if(index < 0){
1283         int i;
1284         AVPacket pkt;
1285
1286         if(st->index_entries && st->nb_index_entries){
1287             ie= &st->index_entries[st->nb_index_entries-1];
1288             url_fseek(&s->pb, ie->pos, SEEK_SET);
1289             av_update_cur_dts(s, st, ie->timestamp);
1290         }else
1291             url_fseek(&s->pb, 0, SEEK_SET);
1292
1293         for(i=0;; i++) {
1294             int ret = av_read_frame(s, &pkt);
1295             if(ret<0)
1296                 break;
1297             av_free_packet(&pkt);
1298             if(stream_index == pkt.stream_index){
1299                 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1300                     break;
1301             }
1302         }
1303         index = av_index_search_timestamp(st, timestamp, flags);
1304     }
1305     if (index < 0)
1306         return -1;
1307
1308     av_read_frame_flush(s);
1309     if (s->iformat->read_seek){
1310         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1311             return 0;
1312     }
1313     ie = &st->index_entries[index];
1314     url_fseek(&s->pb, ie->pos, SEEK_SET);
1315
1316     av_update_cur_dts(s, st, ie->timestamp);
1317
1318     return 0;
1319 }
1320
1321 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1322 {
1323     int ret;
1324     AVStream *st;
1325
1326     av_read_frame_flush(s);
1327
1328     if(flags & AVSEEK_FLAG_BYTE)
1329         return av_seek_frame_byte(s, stream_index, timestamp, flags);
1330
1331     if(stream_index < 0){
1332         stream_index= av_find_default_stream_index(s);
1333         if(stream_index < 0)
1334             return -1;
1335
1336         st= s->streams[stream_index];
1337        /* timestamp for default must be expressed in AV_TIME_BASE units */
1338         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1339     }
1340     st= s->streams[stream_index];
1341
1342     /* first, we try the format specific seek */
1343     if (s->iformat->read_seek)
1344         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1345     else
1346         ret = -1;
1347     if (ret >= 0) {
1348         return 0;
1349     }
1350
1351     if(s->iformat->read_timestamp)
1352         return av_seek_frame_binary(s, stream_index, timestamp, flags);
1353     else
1354         return av_seek_frame_generic(s, stream_index, timestamp, flags);
1355 }
1356
1357 /*******************************************************/
1358
1359 /**
1360  * Returns TRUE if the stream has accurate timings in any stream.
1361  *
1362  * @return TRUE if the stream has accurate timings for at least one component.
1363  */
1364 static int av_has_timings(AVFormatContext *ic)
1365 {
1366     int i;
1367     AVStream *st;
1368
1369     for(i = 0;i < ic->nb_streams; i++) {
1370         st = ic->streams[i];
1371         if (st->start_time != AV_NOPTS_VALUE &&
1372             st->duration != AV_NOPTS_VALUE)
1373             return 1;
1374     }
1375     return 0;
1376 }
1377
1378 /**
1379  * Estimate the stream timings from the one of each components.
1380  *
1381  * Also computes the global bitrate if possible.
1382  */
1383 static void av_update_stream_timings(AVFormatContext *ic)
1384 {
1385     int64_t start_time, start_time1, end_time, end_time1;
1386     int i;
1387     AVStream *st;
1388
1389     start_time = INT64_MAX;
1390     end_time = INT64_MIN;
1391     for(i = 0;i < ic->nb_streams; i++) {
1392         st = ic->streams[i];
1393         if (st->start_time != AV_NOPTS_VALUE) {
1394             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1395             if (start_time1 < start_time)
1396                 start_time = start_time1;
1397             if (st->duration != AV_NOPTS_VALUE) {
1398                 end_time1 = start_time1
1399                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1400                 if (end_time1 > end_time)
1401                     end_time = end_time1;
1402             }
1403         }
1404     }
1405     if (start_time != INT64_MAX) {
1406         ic->start_time = start_time;
1407         if (end_time != INT64_MIN) {
1408             ic->duration = end_time - start_time;
1409             if (ic->file_size > 0) {
1410                 /* compute the bit rate */
1411                 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1412                     (double)ic->duration;
1413             }
1414         }
1415     }
1416
1417 }
1418
1419 static void fill_all_stream_timings(AVFormatContext *ic)
1420 {
1421     int i;
1422     AVStream *st;
1423
1424     av_update_stream_timings(ic);
1425     for(i = 0;i < ic->nb_streams; i++) {
1426         st = ic->streams[i];
1427         if (st->start_time == AV_NOPTS_VALUE) {
1428             if(ic->start_time != AV_NOPTS_VALUE)
1429                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1430             if(ic->duration != AV_NOPTS_VALUE)
1431                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1432         }
1433     }
1434 }
1435
1436 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1437 {
1438     int64_t filesize, duration;
1439     int bit_rate, i;
1440     AVStream *st;
1441
1442     /* if bit_rate is already set, we believe it */
1443     if (ic->bit_rate == 0) {
1444         bit_rate = 0;
1445         for(i=0;i<ic->nb_streams;i++) {
1446             st = ic->streams[i];
1447             bit_rate += st->codec->bit_rate;
1448         }
1449         ic->bit_rate = bit_rate;
1450     }
1451
1452     /* if duration is already set, we believe it */
1453     if (ic->duration == AV_NOPTS_VALUE &&
1454         ic->bit_rate != 0 &&
1455         ic->file_size != 0)  {
1456         filesize = ic->file_size;
1457         if (filesize > 0) {
1458             for(i = 0; i < ic->nb_streams; i++) {
1459                 st = ic->streams[i];
1460                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1461                 if (st->start_time == AV_NOPTS_VALUE ||
1462                     st->duration == AV_NOPTS_VALUE) {
1463                     st->start_time = 0;
1464                     st->duration = duration;
1465                 }
1466             }
1467         }
1468     }
1469 }
1470
1471 #define DURATION_MAX_READ_SIZE 250000
1472
1473 /* only usable for MPEG-PS streams */
1474 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1475 {
1476     AVPacket pkt1, *pkt = &pkt1;
1477     AVStream *st;
1478     int read_size, i, ret;
1479     int64_t end_time;
1480     int64_t filesize, offset, duration;
1481
1482     av_read_frame_flush(ic);
1483
1484     /* we read the first packets to get the first PTS (not fully
1485        accurate, but it is enough now) */
1486     url_fseek(&ic->pb, 0, SEEK_SET);
1487     read_size = 0;
1488     for(;;) {
1489         if (read_size >= DURATION_MAX_READ_SIZE)
1490             break;
1491         /* if all info is available, we can stop */
1492         for(i = 0;i < ic->nb_streams; i++) {
1493             st = ic->streams[i];
1494             if (st->start_time == AV_NOPTS_VALUE)
1495                 break;
1496         }
1497         if (i == ic->nb_streams)
1498             break;
1499
1500         ret = av_read_packet(ic, pkt);
1501         if (ret != 0)
1502             break;
1503         read_size += pkt->size;
1504         st = ic->streams[pkt->stream_index];
1505         if (pkt->pts != AV_NOPTS_VALUE) {
1506             if (st->start_time == AV_NOPTS_VALUE)
1507                 st->start_time = pkt->pts;
1508         }
1509         av_free_packet(pkt);
1510     }
1511
1512     /* estimate the end time (duration) */
1513     /* XXX: may need to support wrapping */
1514     filesize = ic->file_size;
1515     offset = filesize - DURATION_MAX_READ_SIZE;
1516     if (offset < 0)
1517         offset = 0;
1518
1519     url_fseek(&ic->pb, offset, SEEK_SET);
1520     read_size = 0;
1521     for(;;) {
1522         if (read_size >= DURATION_MAX_READ_SIZE)
1523             break;
1524         /* if all info is available, we can stop */
1525         for(i = 0;i < ic->nb_streams; i++) {
1526             st = ic->streams[i];
1527             if (st->duration == AV_NOPTS_VALUE)
1528                 break;
1529         }
1530         if (i == ic->nb_streams)
1531             break;
1532
1533         ret = av_read_packet(ic, pkt);
1534         if (ret != 0)
1535             break;
1536         read_size += pkt->size;
1537         st = ic->streams[pkt->stream_index];
1538         if (pkt->pts != AV_NOPTS_VALUE) {
1539             end_time = pkt->pts;
1540             duration = end_time - st->start_time;
1541             if (duration > 0) {
1542                 if (st->duration == AV_NOPTS_VALUE ||
1543                     st->duration < duration)
1544                     st->duration = duration;
1545             }
1546         }
1547         av_free_packet(pkt);
1548     }
1549
1550     fill_all_stream_timings(ic);
1551
1552     url_fseek(&ic->pb, old_offset, SEEK_SET);
1553 }
1554
1555 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1556 {
1557     int64_t file_size;
1558
1559     /* get the file size, if possible */
1560     if (ic->iformat->flags & AVFMT_NOFILE) {
1561         file_size = 0;
1562     } else {
1563         file_size = url_fsize(&ic->pb);
1564         if (file_size < 0)
1565             file_size = 0;
1566     }
1567     ic->file_size = file_size;
1568
1569     if ((!strcmp(ic->iformat->name, "mpeg") ||
1570          !strcmp(ic->iformat->name, "mpegts")) &&
1571         file_size && !ic->pb.is_streamed) {
1572         /* get accurate estimate from the PTSes */
1573         av_estimate_timings_from_pts(ic, old_offset);
1574     } else if (av_has_timings(ic)) {
1575         /* at least one components has timings - we use them for all
1576            the components */
1577         fill_all_stream_timings(ic);
1578     } else {
1579         /* less precise: use bit rate info */
1580         av_estimate_timings_from_bit_rate(ic);
1581     }
1582     av_update_stream_timings(ic);
1583
1584 #if 0
1585     {
1586         int i;
1587         AVStream *st;
1588         for(i = 0;i < ic->nb_streams; i++) {
1589             st = ic->streams[i];
1590         printf("%d: start_time: %0.3f duration: %0.3f\n",
1591                i, (double)st->start_time / AV_TIME_BASE,
1592                (double)st->duration / AV_TIME_BASE);
1593         }
1594         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1595                (double)ic->start_time / AV_TIME_BASE,
1596                (double)ic->duration / AV_TIME_BASE,
1597                ic->bit_rate / 1000);
1598     }
1599 #endif
1600 }
1601
1602 static int has_codec_parameters(AVCodecContext *enc)
1603 {
1604     int val;
1605     switch(enc->codec_type) {
1606     case CODEC_TYPE_AUDIO:
1607         val = enc->sample_rate;
1608         break;
1609     case CODEC_TYPE_VIDEO:
1610         val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1611         break;
1612     default:
1613         val = 1;
1614         break;
1615     }
1616     return (val != 0);
1617 }
1618
1619 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1620 {
1621     int16_t *samples;
1622     AVCodec *codec;
1623     int got_picture, data_size, ret=0;
1624     AVFrame picture;
1625
1626   if(!st->codec->codec){
1627     codec = avcodec_find_decoder(st->codec->codec_id);
1628     if (!codec)
1629         return -1;
1630     ret = avcodec_open(st->codec, codec);
1631     if (ret < 0)
1632         return ret;
1633   }
1634
1635   if(!has_codec_parameters(st->codec)){
1636     switch(st->codec->codec_type) {
1637     case CODEC_TYPE_VIDEO:
1638         ret = avcodec_decode_video(st->codec, &picture,
1639                                    &got_picture, (uint8_t *)data, size);
1640         break;
1641     case CODEC_TYPE_AUDIO:
1642         data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1643         samples = av_malloc(data_size);
1644         if (!samples)
1645             goto fail;
1646         ret = avcodec_decode_audio2(st->codec, samples,
1647                                     &data_size, (uint8_t *)data, size);
1648         av_free(samples);
1649         break;
1650     default:
1651         break;
1652     }
1653   }
1654  fail:
1655     return ret;
1656 }
1657
1658 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1659 {
1660     AVInputFormat *fmt;
1661     fmt = av_probe_input_format2(pd, 1, &score);
1662
1663     if (fmt) {
1664         if (strncmp(fmt->name, "mp3", 3) == 0)
1665             st->codec->codec_id = CODEC_ID_MP3;
1666         else if (strncmp(fmt->name, "ac3", 3) == 0)
1667             st->codec->codec_id = CODEC_ID_AC3;
1668     }
1669     return fmt;
1670 }
1671
1672 /* absolute maximum size we read until we abort */
1673 #define MAX_READ_SIZE        5000000
1674
1675 #define MAX_STD_TIMEBASES (60*12+5)
1676 static int get_std_framerate(int i){
1677     if(i<60*12) return i*1001;
1678     else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1679 }
1680
1681 int av_find_stream_info(AVFormatContext *ic)
1682 {
1683     int i, count, ret, read_size, j;
1684     AVStream *st;
1685     AVPacket pkt1, *pkt;
1686     AVPacketList *pktl=NULL, **ppktl;
1687     int64_t last_dts[MAX_STREAMS];
1688     int duration_count[MAX_STREAMS]={0};
1689     double (*duration_error)[MAX_STD_TIMEBASES];
1690     offset_t old_offset = url_ftell(&ic->pb);
1691     int64_t codec_info_duration[MAX_STREAMS]={0};
1692     int codec_info_nb_frames[MAX_STREAMS]={0};
1693     AVProbeData probe_data[MAX_STREAMS];
1694     int codec_identified[MAX_STREAMS]={0};
1695
1696     duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1697     if (!duration_error) return AVERROR_NOMEM;
1698
1699     for(i=0;i<ic->nb_streams;i++) {
1700         st = ic->streams[i];
1701         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1702 /*            if(!st->time_base.num)
1703                 st->time_base= */
1704             if(!st->codec->time_base.num)
1705                 st->codec->time_base= st->time_base;
1706         }
1707         //only for the split stuff
1708         if (!st->parser) {
1709             st->parser = av_parser_init(st->codec->codec_id);
1710             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1711                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1712             }
1713         }
1714     }
1715
1716     for(i=0;i<MAX_STREAMS;i++){
1717         last_dts[i]= AV_NOPTS_VALUE;
1718     }
1719
1720     memset(probe_data, 0, sizeof(probe_data));
1721     count = 0;
1722     read_size = 0;
1723     ppktl = &ic->packet_buffer;
1724     for(;;) {
1725         /* check if one codec still needs to be handled */
1726         for(i=0;i<ic->nb_streams;i++) {
1727             st = ic->streams[i];
1728             if (!has_codec_parameters(st->codec))
1729                 break;
1730             /* variable fps and no guess at the real fps */
1731             if(   (st->codec->time_base.den >= 101LL*st->codec->time_base.num || st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
1732                && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1733                 break;
1734             if(st->parser && st->parser->parser->split && !st->codec->extradata)
1735                 break;
1736             if (st->codec->codec_type == CODEC_TYPE_AUDIO &&
1737                 st->codec->codec_id == CODEC_ID_NONE)
1738                 break;
1739         }
1740         if (i == ic->nb_streams) {
1741             /* NOTE: if the format has no header, then we need to read
1742                some packets to get most of the streams, so we cannot
1743                stop here */
1744             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1745                 /* if we found the info for all the codecs, we can stop */
1746                 ret = count;
1747                 break;
1748             }
1749         }
1750         /* we did not get all the codec info, but we read too much data */
1751         if (read_size >= MAX_READ_SIZE) {
1752             ret = count;
1753             break;
1754         }
1755
1756         /* NOTE: a new stream can be added there if no header in file
1757            (AVFMTCTX_NOHEADER) */
1758         ret = av_read_frame_internal(ic, &pkt1);
1759         if (ret < 0) {
1760             /* EOF or error */
1761             ret = -1; /* we could not have all the codec parameters before EOF */
1762             for(i=0;i<ic->nb_streams;i++) {
1763                 st = ic->streams[i];
1764                 if (!has_codec_parameters(st->codec)){
1765                     char buf[256];
1766                     avcodec_string(buf, sizeof(buf), st->codec, 0);
1767                     av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1768                 } else {
1769                     ret = 0;
1770                 }
1771             }
1772             break;
1773         }
1774
1775         pktl = av_mallocz(sizeof(AVPacketList));
1776         if (!pktl) {
1777             ret = AVERROR_NOMEM;
1778             break;
1779         }
1780
1781         /* add the packet in the buffered packet list */
1782         *ppktl = pktl;
1783         ppktl = &pktl->next;
1784
1785         pkt = &pktl->pkt;
1786         *pkt = pkt1;
1787
1788         /* duplicate the packet */
1789         if (av_dup_packet(pkt) < 0) {
1790             ret = AVERROR_NOMEM;
1791             break;
1792         }
1793
1794         read_size += pkt->size;
1795
1796         st = ic->streams[pkt->stream_index];
1797         if(codec_info_nb_frames[st->index]>1)
1798             codec_info_duration[st->index] += pkt->duration;
1799         if (pkt->duration != 0)
1800             codec_info_nb_frames[st->index]++;
1801
1802         {
1803             int index= pkt->stream_index;
1804             int64_t last= last_dts[index];
1805             int64_t duration= pkt->dts - last;
1806
1807             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1808                 double dur= duration * av_q2d(st->time_base);
1809
1810 //                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1811 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1812                 if(duration_count[index] < 2)
1813                     memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1814                 for(i=1; i<MAX_STD_TIMEBASES; i++){
1815                     int framerate= get_std_framerate(i);
1816                     int ticks= lrintf(dur*framerate/(1001*12));
1817                     double error= dur - ticks*1001*12/(double)framerate;
1818                     duration_error[index][i] += error*error;
1819                 }
1820                 duration_count[index]++;
1821             }
1822             if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1823                 last_dts[pkt->stream_index]= pkt->dts;
1824
1825             if (st->codec->codec_id == CODEC_ID_NONE) {
1826                 AVProbeData *pd = &(probe_data[st->index]);
1827                 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size);
1828                 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1829                 pd->buf_size += pkt->size;
1830             }
1831         }
1832         if(st->parser && st->parser->parser->split && !st->codec->extradata){
1833             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1834             if(i){
1835                 st->codec->extradata_size= i;
1836                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1837                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1838                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1839             }
1840         }
1841
1842         /* if still no information, we try to open the codec and to
1843            decompress the frame. We try to avoid that in most cases as
1844            it takes longer and uses more memory. For MPEG4, we need to
1845            decompress for Quicktime. */
1846         if (!has_codec_parameters(st->codec) /*&&
1847             (st->codec->codec_id == CODEC_ID_FLV1 ||
1848              st->codec->codec_id == CODEC_ID_H264 ||
1849              st->codec->codec_id == CODEC_ID_H263 ||
1850              st->codec->codec_id == CODEC_ID_H261 ||
1851              st->codec->codec_id == CODEC_ID_VORBIS ||
1852              st->codec->codec_id == CODEC_ID_MJPEG ||
1853              st->codec->codec_id == CODEC_ID_PNG ||
1854              st->codec->codec_id == CODEC_ID_PAM ||
1855              st->codec->codec_id == CODEC_ID_PGM ||
1856              st->codec->codec_id == CODEC_ID_PGMYUV ||
1857              st->codec->codec_id == CODEC_ID_PBM ||
1858              st->codec->codec_id == CODEC_ID_PPM ||
1859              st->codec->codec_id == CODEC_ID_SHORTEN ||
1860              (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1861             try_decode_frame(st, pkt->data, pkt->size);
1862
1863         if (av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
1864             break;
1865         }
1866         count++;
1867     }
1868
1869     // close codecs which where opened in try_decode_frame()
1870     for(i=0;i<ic->nb_streams;i++) {
1871         st = ic->streams[i];
1872         if(st->codec->codec)
1873             avcodec_close(st->codec);
1874     }
1875     for(i=0;i<ic->nb_streams;i++) {
1876         st = ic->streams[i];
1877         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1878             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1879                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1880
1881             if(duration_count[i]
1882                && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1883                //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1884                st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1885                 double best_error= 2*av_q2d(st->time_base);
1886                 best_error= best_error*best_error*duration_count[i]*1000*12*30;
1887
1888                 for(j=1; j<MAX_STD_TIMEBASES; j++){
1889                     double error= duration_error[i][j] * get_std_framerate(j);
1890 //                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1891 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1892                     if(error < best_error){
1893                         best_error= error;
1894                         av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1895                     }
1896                 }
1897             }
1898
1899             if (!st->r_frame_rate.num){
1900                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
1901                     <= st->codec->time_base.num * (int64_t)st->time_base.den){
1902                     st->r_frame_rate.num = st->codec->time_base.den;
1903                     st->r_frame_rate.den = st->codec->time_base.num;
1904                 }else{
1905                     st->r_frame_rate.num = st->time_base.den;
1906                     st->r_frame_rate.den = st->time_base.num;
1907                 }
1908             }
1909         }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1910             if (st->codec->codec_id == CODEC_ID_NONE) {
1911                 codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 0);
1912                 if (codec_identified[st->index]) {
1913                     st->need_parsing = AVSTREAM_PARSE_FULL;
1914                 }
1915             }
1916             if(!st->codec->bits_per_sample)
1917                 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1918         }
1919     }
1920
1921     av_estimate_timings(ic, old_offset);
1922
1923     for(i=0;i<ic->nb_streams;i++) {
1924         st = ic->streams[i];
1925         if (codec_identified[st->index]) {
1926             av_read_frame_flush(ic);
1927             av_seek_frame(ic, st->index, 0.0, 0);
1928             url_fseek(&ic->pb, ic->data_offset, SEEK_SET);
1929         }
1930     }
1931
1932 #if 0
1933     /* correct DTS for b frame streams with no timestamps */
1934     for(i=0;i<ic->nb_streams;i++) {
1935         st = ic->streams[i];
1936         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1937             if(b-frames){
1938                 ppktl = &ic->packet_buffer;
1939                 while(ppkt1){
1940                     if(ppkt1->stream_index != i)
1941                         continue;
1942                     if(ppkt1->pkt->dts < 0)
1943                         break;
1944                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1945                         break;
1946                     ppkt1->pkt->dts -= delta;
1947                     ppkt1= ppkt1->next;
1948                 }
1949                 if(ppkt1)
1950                     continue;
1951                 st->cur_dts -= delta;
1952             }
1953         }
1954     }
1955 #endif
1956
1957     av_free(duration_error);
1958     for(i=0;i<MAX_STREAMS;i++){
1959         av_freep(&(probe_data[i].buf));
1960     }
1961
1962     return ret;
1963 }
1964
1965 /*******************************************************/
1966
1967 int av_read_play(AVFormatContext *s)
1968 {
1969     if (!s->iformat->read_play)
1970         return AVERROR_NOTSUPP;
1971     return s->iformat->read_play(s);
1972 }
1973
1974 int av_read_pause(AVFormatContext *s)
1975 {
1976     if (!s->iformat->read_pause)
1977         return AVERROR_NOTSUPP;
1978     return s->iformat->read_pause(s);
1979 }
1980
1981 void av_close_input_file(AVFormatContext *s)
1982 {
1983     int i, must_open_file;
1984     AVStream *st;
1985
1986     /* free previous packet */
1987     if (s->cur_st && s->cur_st->parser)
1988         av_free_packet(&s->cur_pkt);
1989
1990     if (s->iformat->read_close)
1991         s->iformat->read_close(s);
1992     for(i=0;i<s->nb_streams;i++) {
1993         /* free all data in a stream component */
1994         st = s->streams[i];
1995         if (st->parser) {
1996             av_parser_close(st->parser);
1997         }
1998         av_free(st->index_entries);
1999         av_free(st->codec->extradata);
2000         av_free(st->codec);
2001         av_free(st);
2002     }
2003     flush_packet_queue(s);
2004     must_open_file = 1;
2005     if (s->iformat->flags & AVFMT_NOFILE) {
2006         must_open_file = 0;
2007     }
2008     if (must_open_file) {
2009         url_fclose(&s->pb);
2010     }
2011     av_freep(&s->priv_data);
2012     av_free(s);
2013 }
2014
2015 AVStream *av_new_stream(AVFormatContext *s, int id)
2016 {
2017     AVStream *st;
2018     int i;
2019
2020     if (s->nb_streams >= MAX_STREAMS)
2021         return NULL;
2022
2023     st = av_mallocz(sizeof(AVStream));
2024     if (!st)
2025         return NULL;
2026
2027     st->codec= avcodec_alloc_context();
2028     if (s->iformat) {
2029         /* no default bitrate if decoding */
2030         st->codec->bit_rate = 0;
2031     }
2032     st->index = s->nb_streams;
2033     st->id = id;
2034     st->start_time = AV_NOPTS_VALUE;
2035     st->duration = AV_NOPTS_VALUE;
2036     st->cur_dts = AV_NOPTS_VALUE;
2037
2038     /* default pts settings is MPEG like */
2039     av_set_pts_info(st, 33, 1, 90000);
2040     st->last_IP_pts = AV_NOPTS_VALUE;
2041     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2042         st->pts_buffer[i]= AV_NOPTS_VALUE;
2043
2044     s->streams[s->nb_streams++] = st;
2045     return st;
2046 }
2047
2048 /************************************************************/
2049 /* output media file */
2050
2051 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2052 {
2053     int ret;
2054
2055     if (s->oformat->priv_data_size > 0) {
2056         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2057         if (!s->priv_data)
2058             return AVERROR_NOMEM;
2059     } else
2060         s->priv_data = NULL;
2061
2062     if (s->oformat->set_parameters) {
2063         ret = s->oformat->set_parameters(s, ap);
2064         if (ret < 0)
2065             return ret;
2066     }
2067     return 0;
2068 }
2069
2070 int av_write_header(AVFormatContext *s)
2071 {
2072     int ret, i;
2073     AVStream *st;
2074
2075     // some sanity checks
2076     for(i=0;i<s->nb_streams;i++) {
2077         st = s->streams[i];
2078
2079         switch (st->codec->codec_type) {
2080         case CODEC_TYPE_AUDIO:
2081             if(st->codec->sample_rate<=0){
2082                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2083                 return -1;
2084             }
2085             break;
2086         case CODEC_TYPE_VIDEO:
2087             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2088                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2089                 return -1;
2090             }
2091             if(st->codec->width<=0 || st->codec->height<=0){
2092                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2093                 return -1;
2094             }
2095             break;
2096         }
2097
2098         if(s->oformat->codec_tag){
2099             if(st->codec->codec_tag){
2100                 //FIXME
2101                 //check that tag + id is in the table
2102                 //if neither is in the table -> ok
2103                 //if tag is in the table with another id -> FAIL
2104                 //if id is in the table with another tag -> FAIL unless strict < ?
2105             }else
2106                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2107         }
2108     }
2109
2110     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2111         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2112         if (!s->priv_data)
2113             return AVERROR_NOMEM;
2114     }
2115
2116     if(s->oformat->write_header){
2117         ret = s->oformat->write_header(s);
2118         if (ret < 0)
2119             return ret;
2120     }
2121
2122     /* init PTS generation */
2123     for(i=0;i<s->nb_streams;i++) {
2124         int64_t den = AV_NOPTS_VALUE;
2125         st = s->streams[i];
2126
2127         switch (st->codec->codec_type) {
2128         case CODEC_TYPE_AUDIO:
2129             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2130             break;
2131         case CODEC_TYPE_VIDEO:
2132             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2133             break;
2134         default:
2135             break;
2136         }
2137         if (den != AV_NOPTS_VALUE) {
2138             if (den <= 0)
2139                 return AVERROR_INVALIDDATA;
2140             av_frac_init(&st->pts, 0, 0, den);
2141         }
2142     }
2143     return 0;
2144 }
2145
2146 //FIXME merge with compute_pkt_fields
2147 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2148     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2149     int num, den, frame_size, i;
2150
2151 //    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);
2152
2153 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2154         return -1;*/
2155
2156     /* duration field */
2157     if (pkt->duration == 0) {
2158         compute_frame_duration(&num, &den, st, NULL, pkt);
2159         if (den && num) {
2160             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2161         }
2162     }
2163
2164     //XXX/FIXME this is a temporary hack until all encoders output pts
2165     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2166         pkt->dts=
2167 //        pkt->pts= st->cur_dts;
2168         pkt->pts= st->pts.val;
2169     }
2170
2171     //calculate dts from pts
2172     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2173         st->pts_buffer[0]= pkt->pts;
2174         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2175             st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2176         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2177             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2178
2179         pkt->dts= st->pts_buffer[0];
2180     }
2181
2182     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2183         av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64" st:%d\n", st->cur_dts, pkt->dts, st->index);
2184         return -1;
2185     }
2186     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2187         av_log(NULL, AV_LOG_ERROR, "error, pts < dts (%"PRId64" < %"PRId64")\n",
2188                pkt->pts, pkt->dts);
2189         return -1;
2190     }
2191
2192 //    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2193     st->cur_dts= pkt->dts;
2194     st->pts.val= pkt->dts;
2195
2196     /* update pts */
2197     switch (st->codec->codec_type) {
2198     case CODEC_TYPE_AUDIO:
2199         frame_size = get_audio_frame_size(st->codec, pkt->size);
2200
2201         /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2202            but it would be better if we had the real timestamps from the encoder */
2203         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2204             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2205         }
2206         break;
2207     case CODEC_TYPE_VIDEO:
2208         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2209         break;
2210     default:
2211         break;
2212     }
2213     return 0;
2214 }
2215
2216 static void truncate_ts(AVStream *st, AVPacket *pkt){
2217     int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2218
2219 //    if(pkt->dts < 0)
2220 //        pkt->dts= 0;  //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2221
2222     if (pkt->pts != AV_NOPTS_VALUE)
2223         pkt->pts &= pts_mask;
2224     if (pkt->dts != AV_NOPTS_VALUE)
2225         pkt->dts &= pts_mask;
2226 }
2227
2228 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2229 {
2230     int ret;
2231
2232     ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2233     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2234         return ret;
2235
2236     truncate_ts(s->streams[pkt->stream_index], pkt);
2237
2238     ret= s->oformat->write_packet(s, pkt);
2239     if(!ret)
2240         ret= url_ferror(&s->pb);
2241     return ret;
2242 }
2243
2244 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2245     AVPacketList *pktl, **next_point, *this_pktl;
2246     int stream_count=0;
2247     int streams[MAX_STREAMS];
2248
2249     if(pkt){
2250         AVStream *st= s->streams[ pkt->stream_index];
2251
2252 //        assert(pkt->destruct != av_destruct_packet); //FIXME
2253
2254         this_pktl = av_mallocz(sizeof(AVPacketList));
2255         this_pktl->pkt= *pkt;
2256         if(pkt->destruct == av_destruct_packet)
2257             pkt->destruct= NULL; // non shared -> must keep original from being freed
2258         else
2259             av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2260
2261         next_point = &s->packet_buffer;
2262         while(*next_point){
2263             AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2264             int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2265             int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2266             if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2267                 break;
2268             next_point= &(*next_point)->next;
2269         }
2270         this_pktl->next= *next_point;
2271         *next_point= this_pktl;
2272     }
2273
2274     memset(streams, 0, sizeof(streams));
2275     pktl= s->packet_buffer;
2276     while(pktl){
2277 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2278         if(streams[ pktl->pkt.stream_index ] == 0)
2279             stream_count++;
2280         streams[ pktl->pkt.stream_index ]++;
2281         pktl= pktl->next;
2282     }
2283
2284     if(s->nb_streams == stream_count || (flush && stream_count)){
2285         pktl= s->packet_buffer;
2286         *out= pktl->pkt;
2287
2288         s->packet_buffer= pktl->next;
2289         av_freep(&pktl);
2290         return 1;
2291     }else{
2292         av_init_packet(out);
2293         return 0;
2294     }
2295 }
2296
2297 /**
2298  * Interleaves a AVPacket correctly so it can be muxed.
2299  * @param out the interleaved packet will be output here
2300  * @param in the input packet
2301  * @param flush 1 if no further packets are available as input and all
2302  *              remaining packets should be output
2303  * @return 1 if a packet was output, 0 if no packet could be output,
2304  *         < 0 if an error occured
2305  */
2306 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2307     if(s->oformat->interleave_packet)
2308         return s->oformat->interleave_packet(s, out, in, flush);
2309     else
2310         return av_interleave_packet_per_dts(s, out, in, flush);
2311 }
2312
2313 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2314     AVStream *st= s->streams[ pkt->stream_index];
2315
2316     //FIXME/XXX/HACK drop zero sized packets
2317     if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2318         return 0;
2319
2320 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2321     if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2322         return -1;
2323
2324     if(pkt->dts == AV_NOPTS_VALUE)
2325         return -1;
2326
2327     for(;;){
2328         AVPacket opkt;
2329         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2330         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2331             return ret;
2332
2333         truncate_ts(s->streams[opkt.stream_index], &opkt);
2334         ret= s->oformat->write_packet(s, &opkt);
2335
2336         av_free_packet(&opkt);
2337         pkt= NULL;
2338
2339         if(ret<0)
2340             return ret;
2341         if(url_ferror(&s->pb))
2342             return url_ferror(&s->pb);
2343     }
2344 }
2345
2346 int av_write_trailer(AVFormatContext *s)
2347 {
2348     int ret, i;
2349
2350     for(;;){
2351         AVPacket pkt;
2352         ret= av_interleave_packet(s, &pkt, NULL, 1);
2353         if(ret<0) //FIXME cleanup needed for ret<0 ?
2354             goto fail;
2355         if(!ret)
2356             break;
2357
2358         truncate_ts(s->streams[pkt.stream_index], &pkt);
2359         ret= s->oformat->write_packet(s, &pkt);
2360
2361         av_free_packet(&pkt);
2362
2363         if(ret<0)
2364             goto fail;
2365         if(url_ferror(&s->pb))
2366             goto fail;
2367     }
2368
2369     if(s->oformat->write_trailer)
2370         ret = s->oformat->write_trailer(s);
2371 fail:
2372     if(ret == 0)
2373        ret=url_ferror(&s->pb);
2374     for(i=0;i<s->nb_streams;i++)
2375         av_freep(&s->streams[i]->priv_data);
2376     av_freep(&s->priv_data);
2377     return ret;
2378 }
2379
2380 /* "user interface" functions */
2381
2382 void dump_format(AVFormatContext *ic,
2383                  int index,
2384                  const char *url,
2385                  int is_output)
2386 {
2387     int i, flags;
2388     char buf[256];
2389
2390     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2391             is_output ? "Output" : "Input",
2392             index,
2393             is_output ? ic->oformat->name : ic->iformat->name,
2394             is_output ? "to" : "from", url);
2395     if (!is_output) {
2396         av_log(NULL, AV_LOG_INFO, "  Duration: ");
2397         if (ic->duration != AV_NOPTS_VALUE) {
2398             int hours, mins, secs, us;
2399             secs = ic->duration / AV_TIME_BASE;
2400             us = ic->duration % AV_TIME_BASE;
2401             mins = secs / 60;
2402             secs %= 60;
2403             hours = mins / 60;
2404             mins %= 60;
2405             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2406                    (10 * us) / AV_TIME_BASE);
2407         } else {
2408             av_log(NULL, AV_LOG_INFO, "N/A");
2409         }
2410         if (ic->start_time != AV_NOPTS_VALUE) {
2411             int secs, us;
2412             av_log(NULL, AV_LOG_INFO, ", start: ");
2413             secs = ic->start_time / AV_TIME_BASE;
2414             us = ic->start_time % AV_TIME_BASE;
2415             av_log(NULL, AV_LOG_INFO, "%d.%06d",
2416                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2417         }
2418         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2419         if (ic->bit_rate) {
2420             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2421         } else {
2422             av_log(NULL, AV_LOG_INFO, "N/A");
2423         }
2424         av_log(NULL, AV_LOG_INFO, "\n");
2425     }
2426     for(i=0;i<ic->nb_streams;i++) {
2427         AVStream *st = ic->streams[i];
2428         int g= ff_gcd(st->time_base.num, st->time_base.den);
2429         avcodec_string(buf, sizeof(buf), st->codec, is_output);
2430         av_log(NULL, AV_LOG_INFO, "  Stream #%d.%d", index, i);
2431         /* the pid is an important information, so we display it */
2432         /* XXX: add a generic system */
2433         if (is_output)
2434             flags = ic->oformat->flags;
2435         else
2436             flags = ic->iformat->flags;
2437         if (flags & AVFMT_SHOW_IDS) {
2438             av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2439         }
2440         if (strlen(st->language) > 0) {
2441             av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2442         }
2443         av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2444         av_log(NULL, AV_LOG_INFO, ": %s", buf);
2445         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2446             if(st->r_frame_rate.den && st->r_frame_rate.num)
2447                 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2448 /*            else if(st->time_base.den && st->time_base.num)
2449                 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2450             else
2451                 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2452         }
2453         av_log(NULL, AV_LOG_INFO, "\n");
2454     }
2455 }
2456
2457 typedef struct {
2458     const char *abv;
2459     int width, height;
2460     int frame_rate, frame_rate_base;
2461 } AbvEntry;
2462
2463 static AbvEntry frame_abvs[] = {
2464     { "ntsc",      720, 480, 30000, 1001 },
2465     { "pal",       720, 576,    25,    1 },
2466     { "qntsc",     352, 240, 30000, 1001 }, /* VCD compliant ntsc */
2467     { "qpal",      352, 288,    25,    1 }, /* VCD compliant pal */
2468     { "sntsc",     640, 480, 30000, 1001 }, /* square pixel ntsc */
2469     { "spal",      768, 576,    25,    1 }, /* square pixel pal */
2470     { "film",      352, 240,    24,    1 },
2471     { "ntsc-film", 352, 240, 24000, 1001 },
2472     { "sqcif",     128,  96,     0,    0 },
2473     { "qcif",      176, 144,     0,    0 },
2474     { "cif",       352, 288,     0,    0 },
2475     { "4cif",      704, 576,     0,    0 },
2476 };
2477
2478 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2479 {
2480     int i;
2481     int n = sizeof(frame_abvs) / sizeof(AbvEntry);
2482     const char *p;
2483     int frame_width = 0, frame_height = 0;
2484
2485     for(i=0;i<n;i++) {
2486         if (!strcmp(frame_abvs[i].abv, str)) {
2487             frame_width = frame_abvs[i].width;
2488             frame_height = frame_abvs[i].height;
2489             break;
2490         }
2491     }
2492     if (i == n) {
2493         p = str;
2494         frame_width = strtol(p, (char **)&p, 10);
2495         if (*p)
2496             p++;
2497         frame_height = strtol(p, (char **)&p, 10);
2498     }
2499     if (frame_width <= 0 || frame_height <= 0)
2500         return -1;
2501     *width_ptr = frame_width;
2502     *height_ptr = frame_height;
2503     return 0;
2504 }
2505
2506 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
2507 {
2508     int i;
2509     char* cp;
2510
2511     /* First, we check our abbreviation table */
2512     for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
2513          if (!strcmp(frame_abvs[i].abv, arg)) {
2514              *frame_rate = frame_abvs[i].frame_rate;
2515              *frame_rate_base = frame_abvs[i].frame_rate_base;
2516              return 0;
2517          }
2518
2519     /* Then, we try to parse it as fraction */
2520     cp = strchr(arg, '/');
2521     if (!cp)
2522         cp = strchr(arg, ':');
2523     if (cp) {
2524         char* cpp;
2525         *frame_rate = strtol(arg, &cpp, 10);
2526         if (cpp != arg || cpp == cp)
2527             *frame_rate_base = strtol(cp+1, &cpp, 10);
2528         else
2529            *frame_rate = 0;
2530     }
2531     else {
2532         /* Finally we give up and parse it as double */
2533         AVRational time_base = av_d2q(strtod(arg, 0), DEFAULT_FRAME_RATE_BASE);
2534         *frame_rate_base = time_base.den;
2535         *frame_rate = time_base.num;
2536     }
2537     if (!*frame_rate || !*frame_rate_base)
2538         return -1;
2539     else
2540         return 0;
2541 }
2542
2543 int64_t parse_date(const char *datestr, int duration)
2544 {
2545     const char *p;
2546     int64_t t;
2547     struct tm dt;
2548     int i;
2549     static const char *date_fmt[] = {
2550         "%Y-%m-%d",
2551         "%Y%m%d",
2552     };
2553     static const char *time_fmt[] = {
2554         "%H:%M:%S",
2555         "%H%M%S",
2556     };
2557     const char *q;
2558     int is_utc, len;
2559     char lastch;
2560     int negative = 0;
2561
2562 #undef time
2563     time_t now = time(0);
2564
2565     len = strlen(datestr);
2566     if (len > 0)
2567         lastch = datestr[len - 1];
2568     else
2569         lastch = '\0';
2570     is_utc = (lastch == 'z' || lastch == 'Z');
2571
2572     memset(&dt, 0, sizeof(dt));
2573
2574     p = datestr;
2575     q = NULL;
2576     if (!duration) {
2577         for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2578             q = small_strptime(p, date_fmt[i], &dt);
2579             if (q) {
2580                 break;
2581             }
2582         }
2583
2584         if (!q) {
2585             if (is_utc) {
2586                 dt = *gmtime(&now);
2587             } else {
2588                 dt = *localtime(&now);
2589             }
2590             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2591         } else {
2592             p = q;
2593         }
2594
2595         if (*p == 'T' || *p == 't' || *p == ' ')
2596             p++;
2597
2598         for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2599             q = small_strptime(p, time_fmt[i], &dt);
2600             if (q) {
2601                 break;
2602             }
2603         }
2604     } else {
2605         if (p[0] == '-') {
2606             negative = 1;
2607             ++p;
2608         }
2609         q = small_strptime(p, time_fmt[0], &dt);
2610         if (!q) {
2611             dt.tm_sec = strtol(p, (char **)&q, 10);
2612             dt.tm_min = 0;
2613             dt.tm_hour = 0;
2614         }
2615     }
2616
2617     /* Now we have all the fields that we can get */
2618     if (!q) {
2619         if (duration)
2620             return 0;
2621         else
2622             return now * INT64_C(1000000);
2623     }
2624
2625     if (duration) {
2626         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2627     } else {
2628         dt.tm_isdst = -1;       /* unknown */
2629         if (is_utc) {
2630             t = mktimegm(&dt);
2631         } else {
2632             t = mktime(&dt);
2633         }
2634     }
2635
2636     t *= 1000000;
2637
2638     if (*q == '.') {
2639         int val, n;
2640         q++;
2641         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2642             if (!isdigit(*q))
2643                 break;
2644             val += n * (*q - '0');
2645         }
2646         t += val;
2647     }
2648     return negative ? -t : t;
2649 }
2650
2651 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2652 {
2653     const char *p;
2654     char tag[128], *q;
2655
2656     p = info;
2657     if (*p == '?')
2658         p++;
2659     for(;;) {
2660         q = tag;
2661         while (*p != '\0' && *p != '=' && *p != '&') {
2662             if ((q - tag) < sizeof(tag) - 1)
2663                 *q++ = *p;
2664             p++;
2665         }
2666         *q = '\0';
2667         q = arg;
2668         if (*p == '=') {
2669             p++;
2670             while (*p != '&' && *p != '\0') {
2671                 if ((q - arg) < arg_size - 1) {
2672                     if (*p == '+')
2673                         *q++ = ' ';
2674                     else
2675                         *q++ = *p;
2676                 }
2677                 p++;
2678             }
2679             *q = '\0';
2680         }
2681         if (!strcmp(tag, tag1))
2682             return 1;
2683         if (*p != '&')
2684             break;
2685         p++;
2686     }
2687     return 0;
2688 }
2689
2690 int av_get_frame_filename(char *buf, int buf_size,
2691                           const char *path, int number)
2692 {
2693     const char *p;
2694     char *q, buf1[20], c;
2695     int nd, len, percentd_found;
2696
2697     q = buf;
2698     p = path;
2699     percentd_found = 0;
2700     for(;;) {
2701         c = *p++;
2702         if (c == '\0')
2703             break;
2704         if (c == '%') {
2705             do {
2706                 nd = 0;
2707                 while (isdigit(*p)) {
2708                     nd = nd * 10 + *p++ - '0';
2709                 }
2710                 c = *p++;
2711             } while (isdigit(c));
2712
2713             switch(c) {
2714             case '%':
2715                 goto addchar;
2716             case 'd':
2717                 if (percentd_found)
2718                     goto fail;
2719                 percentd_found = 1;
2720                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2721                 len = strlen(buf1);
2722                 if ((q - buf + len) > buf_size - 1)
2723                     goto fail;
2724                 memcpy(q, buf1, len);
2725                 q += len;
2726                 break;
2727             default:
2728                 goto fail;
2729             }
2730         } else {
2731         addchar:
2732             if ((q - buf) < buf_size - 1)
2733                 *q++ = c;
2734         }
2735     }
2736     if (!percentd_found)
2737         goto fail;
2738     *q = '\0';
2739     return 0;
2740  fail:
2741     *q = '\0';
2742     return -1;
2743 }
2744
2745 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2746 {
2747     int len, i, j, c;
2748 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2749
2750     for(i=0;i<size;i+=16) {
2751         len = size - i;
2752         if (len > 16)
2753             len = 16;
2754         PRINT("%08x ", i);
2755         for(j=0;j<16;j++) {
2756             if (j < len)
2757                 PRINT(" %02x", buf[i+j]);
2758             else
2759                 PRINT("   ");
2760         }
2761         PRINT(" ");
2762         for(j=0;j<len;j++) {
2763             c = buf[i+j];
2764             if (c < ' ' || c > '~')
2765                 c = '.';
2766             PRINT("%c", c);
2767         }
2768         PRINT("\n");
2769     }
2770 #undef PRINT
2771 }
2772
2773 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2774 {
2775     hex_dump_internal(NULL, f, 0, buf, size);
2776 }
2777
2778 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2779 {
2780     hex_dump_internal(avcl, NULL, level, buf, size);
2781 }
2782
2783  //FIXME needs to know the time_base
2784 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2785 {
2786 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2787     PRINT("stream #%d:\n", pkt->stream_index);
2788     PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2789     PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2790     /* DTS is _always_ valid after av_read_frame() */
2791     PRINT("  dts=");
2792     if (pkt->dts == AV_NOPTS_VALUE)
2793         PRINT("N/A");
2794     else
2795         PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2796     /* PTS may be not known if B frames are present */
2797     PRINT("  pts=");
2798     if (pkt->pts == AV_NOPTS_VALUE)
2799         PRINT("N/A");
2800     else
2801         PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2802     PRINT("\n");
2803     PRINT("  size=%d\n", pkt->size);
2804 #undef PRINT
2805     if (dump_payload)
2806         av_hex_dump(f, pkt->data, pkt->size);
2807 }
2808
2809 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2810 {
2811     pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2812 }
2813
2814 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2815 {
2816     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2817 }
2818
2819 void url_split(char *proto, int proto_size,
2820                char *authorization, int authorization_size,
2821                char *hostname, int hostname_size,
2822                int *port_ptr,
2823                char *path, int path_size,
2824                const char *url)
2825 {
2826     const char *p;
2827     char *q;
2828     int port;
2829
2830     port = -1;
2831
2832     p = url;
2833     q = proto;
2834     while (*p != ':' && *p != '\0') {
2835         if ((q - proto) < proto_size - 1)
2836             *q++ = *p;
2837         p++;
2838     }
2839     if (proto_size > 0)
2840         *q = '\0';
2841     if (authorization_size > 0)
2842         authorization[0] = '\0';
2843     if (*p == '\0') {
2844         if (proto_size > 0)
2845             proto[0] = '\0';
2846         if (hostname_size > 0)
2847             hostname[0] = '\0';
2848         p = url;
2849     } else {
2850         char *at,*slash; // PETR: position of '@' character and '/' character
2851
2852         p++;
2853         if (*p == '/')
2854             p++;
2855         if (*p == '/')
2856             p++;
2857         at = strchr(p,'@'); // PETR: get the position of '@'
2858         slash = strchr(p,'/');  // PETR: get position of '/' - end of hostname
2859         if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2860
2861         q = at ? authorization : hostname;  // PETR: if '@' exists starting with auth.
2862
2863          while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2864             if (*p == '@') {    // PETR: passed '@'
2865               if (authorization_size > 0)
2866                   *q = '\0';
2867               q = hostname;
2868               at = NULL;
2869             } else if (!at) {   // PETR: hostname
2870               if ((q - hostname) < hostname_size - 1)
2871                   *q++ = *p;
2872             } else {
2873               if ((q - authorization) < authorization_size - 1)
2874                 *q++ = *p;
2875             }
2876             p++;
2877         }
2878         if (hostname_size > 0)
2879             *q = '\0';
2880         if (*p == ':') {
2881             p++;
2882             port = strtoul(p, (char **)&p, 10);
2883         }
2884     }
2885     if (port_ptr)
2886         *port_ptr = port;
2887     pstrcpy(path, path_size, p);
2888 }
2889
2890 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2891                      int pts_num, int pts_den)
2892 {
2893     s->pts_wrap_bits = pts_wrap_bits;
2894     s->time_base.num = pts_num;
2895     s->time_base.den = pts_den;
2896 }
2897
2898 /* fraction handling */
2899
2900 /**
2901  * f = val + (num / den) + 0.5.
2902  *
2903  * 'num' is normalized so that it is such as 0 <= num < den.
2904  *
2905  * @param f fractional number
2906  * @param val integer value
2907  * @param num must be >= 0
2908  * @param den must be >= 1
2909  */
2910 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2911 {
2912     num += (den >> 1);
2913     if (num >= den) {
2914         val += num / den;
2915         num = num % den;
2916     }
2917     f->val = val;
2918     f->num = num;
2919     f->den = den;
2920 }
2921
2922 /**
2923  * Fractionnal addition to f: f = f + (incr / f->den).
2924  *
2925  * @param f fractional number
2926  * @param incr increment, can be positive or negative
2927  */
2928 static void av_frac_add(AVFrac *f, int64_t incr)
2929 {
2930     int64_t num, den;
2931
2932     num = f->num + incr;
2933     den = f->den;
2934     if (num < 0) {
2935         f->val += num / den;
2936         num = num % den;
2937         if (num < 0) {
2938             num += den;
2939             f->val--;
2940         }
2941     } else if (num >= den) {
2942         f->val += num / den;
2943         num = num % den;
2944     }
2945     f->num = num;
2946 }