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