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