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