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