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