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