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