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