e37577dbd7bcd3a47a14c12cd87de1a9208c127b
[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 <=1){
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->last_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->index_entries && st->nb_index_entries){
1358             ie= &st->index_entries[st->nb_index_entries-1];
1359             url_fseek(s->pb, ie->pos, SEEK_SET);
1360             av_update_cur_dts(s, st, ie->timestamp);
1361         }else
1362             url_fseek(s->pb, 0, SEEK_SET);
1363
1364         for(i=0;; i++) {
1365             int ret = av_read_frame(s, &pkt);
1366             if(ret<0)
1367                 break;
1368             av_free_packet(&pkt);
1369             if(stream_index == pkt.stream_index){
1370                 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1371                     break;
1372             }
1373         }
1374         index = av_index_search_timestamp(st, timestamp, flags);
1375     }
1376     if (index < 0)
1377         return -1;
1378
1379     av_read_frame_flush(s);
1380     if (s->iformat->read_seek){
1381         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1382             return 0;
1383     }
1384     ie = &st->index_entries[index];
1385     url_fseek(s->pb, ie->pos, SEEK_SET);
1386
1387     av_update_cur_dts(s, st, ie->timestamp);
1388
1389     return 0;
1390 }
1391
1392 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1393 {
1394     int ret;
1395     AVStream *st;
1396
1397     av_read_frame_flush(s);
1398
1399     if(flags & AVSEEK_FLAG_BYTE)
1400         return av_seek_frame_byte(s, stream_index, timestamp, flags);
1401
1402     if(stream_index < 0){
1403         stream_index= av_find_default_stream_index(s);
1404         if(stream_index < 0)
1405             return -1;
1406
1407         st= s->streams[stream_index];
1408        /* timestamp for default must be expressed in AV_TIME_BASE units */
1409         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1410     }
1411     st= s->streams[stream_index];
1412
1413     /* first, we try the format specific seek */
1414     if (s->iformat->read_seek)
1415         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1416     else
1417         ret = -1;
1418     if (ret >= 0) {
1419         return 0;
1420     }
1421
1422     if(s->iformat->read_timestamp)
1423         return av_seek_frame_binary(s, stream_index, timestamp, flags);
1424     else
1425         return av_seek_frame_generic(s, stream_index, timestamp, flags);
1426 }
1427
1428 /*******************************************************/
1429
1430 /**
1431  * Returns TRUE if the stream has accurate duration in any stream.
1432  *
1433  * @return TRUE if the stream has accurate duration for at least one component.
1434  */
1435 static int av_has_duration(AVFormatContext *ic)
1436 {
1437     int i;
1438     AVStream *st;
1439
1440     for(i = 0;i < ic->nb_streams; i++) {
1441         st = ic->streams[i];
1442         if (st->duration != AV_NOPTS_VALUE)
1443             return 1;
1444     }
1445     return 0;
1446 }
1447
1448 /**
1449  * Estimate the stream timings from the one of each components.
1450  *
1451  * Also computes the global bitrate if possible.
1452  */
1453 static void av_update_stream_timings(AVFormatContext *ic)
1454 {
1455     int64_t start_time, start_time1, end_time, end_time1;
1456     int64_t duration, duration1;
1457     int i;
1458     AVStream *st;
1459
1460     start_time = INT64_MAX;
1461     end_time = INT64_MIN;
1462     duration = INT64_MIN;
1463     for(i = 0;i < ic->nb_streams; i++) {
1464         st = ic->streams[i];
1465         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1466             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1467             if (start_time1 < start_time)
1468                 start_time = start_time1;
1469             if (st->duration != AV_NOPTS_VALUE) {
1470                 end_time1 = start_time1
1471                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1472                 if (end_time1 > end_time)
1473                     end_time = end_time1;
1474             }
1475         }
1476         if (st->duration != AV_NOPTS_VALUE) {
1477             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1478             if (duration1 > duration)
1479                 duration = duration1;
1480         }
1481     }
1482     if (start_time != INT64_MAX) {
1483         ic->start_time = start_time;
1484         if (end_time != INT64_MIN) {
1485             if (end_time - start_time > duration)
1486                 duration = end_time - start_time;
1487         }
1488     }
1489     if (duration != INT64_MIN) {
1490         ic->duration = duration;
1491         if (ic->file_size > 0) {
1492             /* compute the bitrate */
1493             ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1494                 (double)ic->duration;
1495         }
1496     }
1497 }
1498
1499 static void fill_all_stream_timings(AVFormatContext *ic)
1500 {
1501     int i;
1502     AVStream *st;
1503
1504     av_update_stream_timings(ic);
1505     for(i = 0;i < ic->nb_streams; i++) {
1506         st = ic->streams[i];
1507         if (st->start_time == AV_NOPTS_VALUE) {
1508             if(ic->start_time != AV_NOPTS_VALUE)
1509                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1510             if(ic->duration != AV_NOPTS_VALUE)
1511                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1512         }
1513     }
1514 }
1515
1516 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1517 {
1518     int64_t filesize, duration;
1519     int bit_rate, i;
1520     AVStream *st;
1521
1522     /* if bit_rate is already set, we believe it */
1523     if (ic->bit_rate == 0) {
1524         bit_rate = 0;
1525         for(i=0;i<ic->nb_streams;i++) {
1526             st = ic->streams[i];
1527             bit_rate += st->codec->bit_rate;
1528         }
1529         ic->bit_rate = bit_rate;
1530     }
1531
1532     /* if duration is already set, we believe it */
1533     if (ic->duration == AV_NOPTS_VALUE &&
1534         ic->bit_rate != 0 &&
1535         ic->file_size != 0)  {
1536         filesize = ic->file_size;
1537         if (filesize > 0) {
1538             for(i = 0; i < ic->nb_streams; i++) {
1539                 st = ic->streams[i];
1540                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1541                 if (st->duration == AV_NOPTS_VALUE)
1542                     st->duration = duration;
1543             }
1544         }
1545     }
1546 }
1547
1548 #define DURATION_MAX_READ_SIZE 250000
1549
1550 /* only usable for MPEG-PS streams */
1551 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1552 {
1553     AVPacket pkt1, *pkt = &pkt1;
1554     AVStream *st;
1555     int read_size, i, ret;
1556     int64_t end_time;
1557     int64_t filesize, offset, duration;
1558
1559     /* free previous packet */
1560     if (ic->cur_st && ic->cur_st->parser)
1561         av_free_packet(&ic->cur_pkt);
1562     ic->cur_st = NULL;
1563
1564     /* flush packet queue */
1565     flush_packet_queue(ic);
1566
1567     for(i=0;i<ic->nb_streams;i++) {
1568         st = ic->streams[i];
1569         if (st->parser) {
1570             av_parser_close(st->parser);
1571             st->parser= NULL;
1572         }
1573     }
1574
1575     /* we read the first packets to get the first PTS (not fully
1576        accurate, but it is enough now) */
1577     url_fseek(ic->pb, 0, SEEK_SET);
1578     read_size = 0;
1579     for(;;) {
1580         if (read_size >= DURATION_MAX_READ_SIZE)
1581             break;
1582         /* if all info is available, we can stop */
1583         for(i = 0;i < ic->nb_streams; i++) {
1584             st = ic->streams[i];
1585             if (st->start_time == AV_NOPTS_VALUE)
1586                 break;
1587         }
1588         if (i == ic->nb_streams)
1589             break;
1590
1591         ret = av_read_packet(ic, pkt);
1592         if (ret != 0)
1593             break;
1594         read_size += pkt->size;
1595         st = ic->streams[pkt->stream_index];
1596         if (pkt->pts != AV_NOPTS_VALUE) {
1597             if (st->start_time == AV_NOPTS_VALUE)
1598                 st->start_time = pkt->pts;
1599         }
1600         av_free_packet(pkt);
1601     }
1602
1603     /* estimate the end time (duration) */
1604     /* XXX: may need to support wrapping */
1605     filesize = ic->file_size;
1606     offset = filesize - DURATION_MAX_READ_SIZE;
1607     if (offset < 0)
1608         offset = 0;
1609
1610     url_fseek(ic->pb, offset, SEEK_SET);
1611     read_size = 0;
1612     for(;;) {
1613         if (read_size >= DURATION_MAX_READ_SIZE)
1614             break;
1615
1616         ret = av_read_packet(ic, pkt);
1617         if (ret != 0)
1618             break;
1619         read_size += pkt->size;
1620         st = ic->streams[pkt->stream_index];
1621         if (pkt->pts != AV_NOPTS_VALUE &&
1622             st->start_time != AV_NOPTS_VALUE) {
1623             end_time = pkt->pts;
1624             duration = end_time - st->start_time;
1625             if (duration > 0) {
1626                 if (st->duration == AV_NOPTS_VALUE ||
1627                     st->duration < duration)
1628                     st->duration = duration;
1629             }
1630         }
1631         av_free_packet(pkt);
1632     }
1633
1634     fill_all_stream_timings(ic);
1635
1636     url_fseek(ic->pb, old_offset, SEEK_SET);
1637     for(i=0; i<ic->nb_streams; i++){
1638         st= ic->streams[i];
1639         st->cur_dts= st->first_dts;
1640         st->last_IP_pts = AV_NOPTS_VALUE;
1641     }
1642 }
1643
1644 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1645 {
1646     int64_t file_size;
1647
1648     /* get the file size, if possible */
1649     if (ic->iformat->flags & AVFMT_NOFILE) {
1650         file_size = 0;
1651     } else {
1652         file_size = url_fsize(ic->pb);
1653         if (file_size < 0)
1654             file_size = 0;
1655     }
1656     ic->file_size = file_size;
1657
1658     if ((!strcmp(ic->iformat->name, "mpeg") ||
1659          !strcmp(ic->iformat->name, "mpegts")) &&
1660         file_size && !url_is_streamed(ic->pb)) {
1661         /* get accurate estimate from the PTSes */
1662         av_estimate_timings_from_pts(ic, old_offset);
1663     } else if (av_has_duration(ic)) {
1664         /* at least one component has timings - we use them for all
1665            the components */
1666         fill_all_stream_timings(ic);
1667     } else {
1668         /* less precise: use bitrate info */
1669         av_estimate_timings_from_bit_rate(ic);
1670     }
1671     av_update_stream_timings(ic);
1672
1673 #if 0
1674     {
1675         int i;
1676         AVStream *st;
1677         for(i = 0;i < ic->nb_streams; i++) {
1678             st = ic->streams[i];
1679         printf("%d: start_time: %0.3f duration: %0.3f\n",
1680                i, (double)st->start_time / AV_TIME_BASE,
1681                (double)st->duration / AV_TIME_BASE);
1682         }
1683         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1684                (double)ic->start_time / AV_TIME_BASE,
1685                (double)ic->duration / AV_TIME_BASE,
1686                ic->bit_rate / 1000);
1687     }
1688 #endif
1689 }
1690
1691 static int has_codec_parameters(AVCodecContext *enc)
1692 {
1693     int val;
1694     switch(enc->codec_type) {
1695     case CODEC_TYPE_AUDIO:
1696         val = enc->sample_rate;
1697         break;
1698     case CODEC_TYPE_VIDEO:
1699         val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1700         break;
1701     default:
1702         val = 1;
1703         break;
1704     }
1705     return enc->codec_id != CODEC_ID_NONE && val != 0;
1706 }
1707
1708 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1709 {
1710     int16_t *samples;
1711     AVCodec *codec;
1712     int got_picture, data_size, ret=0;
1713     AVFrame picture;
1714
1715   if(!st->codec->codec){
1716     codec = avcodec_find_decoder(st->codec->codec_id);
1717     if (!codec)
1718         return -1;
1719     ret = avcodec_open(st->codec, codec);
1720     if (ret < 0)
1721         return ret;
1722   }
1723
1724   if(!has_codec_parameters(st->codec)){
1725     switch(st->codec->codec_type) {
1726     case CODEC_TYPE_VIDEO:
1727         ret = avcodec_decode_video(st->codec, &picture,
1728                                    &got_picture, data, size);
1729         break;
1730     case CODEC_TYPE_AUDIO:
1731         data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1732         samples = av_malloc(data_size);
1733         if (!samples)
1734             goto fail;
1735         ret = avcodec_decode_audio2(st->codec, samples,
1736                                     &data_size, data, size);
1737         av_free(samples);
1738         break;
1739     default:
1740         break;
1741     }
1742   }
1743  fail:
1744     return ret;
1745 }
1746
1747 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1748 {
1749     AVInputFormat *fmt;
1750     fmt = av_probe_input_format2(pd, 1, &score);
1751
1752     if (fmt) {
1753         if (strncmp(fmt->name, "mp3", 3) == 0)
1754             st->codec->codec_id = CODEC_ID_MP3;
1755         else if (strncmp(fmt->name, "ac3", 3) == 0)
1756             st->codec->codec_id = CODEC_ID_AC3;
1757     }
1758     return !!fmt;
1759 }
1760
1761 unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1762 {
1763     while (tags->id != CODEC_ID_NONE) {
1764         if (tags->id == id)
1765             return tags->tag;
1766         tags++;
1767     }
1768     return 0;
1769 }
1770
1771 enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1772 {
1773     int i;
1774     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1775         if(tag == tags[i].tag)
1776             return tags[i].id;
1777     }
1778     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1779         if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1780            && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1781            && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1782            && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1783             return tags[i].id;
1784     }
1785     return CODEC_ID_NONE;
1786 }
1787
1788 unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1789 {
1790     int i;
1791     for(i=0; tags && tags[i]; i++){
1792         int tag= codec_get_tag(tags[i], id);
1793         if(tag) return tag;
1794     }
1795     return 0;
1796 }
1797
1798 enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1799 {
1800     int i;
1801     for(i=0; tags && tags[i]; i++){
1802         enum CodecID id= codec_get_id(tags[i], tag);
1803         if(id!=CODEC_ID_NONE) return id;
1804     }
1805     return CODEC_ID_NONE;
1806 }
1807
1808 /* absolute maximum size we read until we abort */
1809 #define MAX_READ_SIZE        5000000
1810
1811 #define MAX_STD_TIMEBASES (60*12+5)
1812 static int get_std_framerate(int i){
1813     if(i<60*12) return i*1001;
1814     else        return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1815 }
1816
1817 /*
1818  * Is the time base unreliable.
1819  * This is a heuristic to balance between quick acceptance of the values in
1820  * the headers vs. some extra checks.
1821  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
1822  * MPEG-2 commonly misuses field repeat flags to store different framerates.
1823  * And there are "variable" fps files this needs to detect as well.
1824  */
1825 static int tb_unreliable(AVCodecContext *c){
1826     if(   c->time_base.den >= 101L*c->time_base.num
1827        || c->time_base.den <    5L*c->time_base.num
1828 /*       || c->codec_tag == ff_get_fourcc("DIVX")
1829        || c->codec_tag == ff_get_fourcc("XVID")*/
1830        || c->codec_id == CODEC_ID_MPEG2VIDEO)
1831         return 1;
1832     return 0;
1833 }
1834
1835 int av_find_stream_info(AVFormatContext *ic)
1836 {
1837     int i, count, ret, read_size, j;
1838     AVStream *st;
1839     AVPacket pkt1, *pkt;
1840     int64_t last_dts[MAX_STREAMS];
1841     int duration_count[MAX_STREAMS]={0};
1842     double (*duration_error)[MAX_STD_TIMEBASES];
1843     offset_t old_offset = url_ftell(ic->pb);
1844     int64_t codec_info_duration[MAX_STREAMS]={0};
1845     int codec_info_nb_frames[MAX_STREAMS]={0};
1846     AVProbeData probe_data[MAX_STREAMS];
1847     int codec_identified[MAX_STREAMS]={0};
1848
1849     duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1850     if (!duration_error) return AVERROR(ENOMEM);
1851
1852     for(i=0;i<ic->nb_streams;i++) {
1853         st = ic->streams[i];
1854         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1855 /*            if(!st->time_base.num)
1856                 st->time_base= */
1857             if(!st->codec->time_base.num)
1858                 st->codec->time_base= st->time_base;
1859         }
1860         //only for the split stuff
1861         if (!st->parser) {
1862             st->parser = av_parser_init(st->codec->codec_id);
1863             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1864                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1865             }
1866         }
1867     }
1868
1869     for(i=0;i<MAX_STREAMS;i++){
1870         last_dts[i]= AV_NOPTS_VALUE;
1871     }
1872
1873     memset(probe_data, 0, sizeof(probe_data));
1874     count = 0;
1875     read_size = 0;
1876     for(;;) {
1877         /* check if one codec still needs to be handled */
1878         for(i=0;i<ic->nb_streams;i++) {
1879             st = ic->streams[i];
1880             if (!has_codec_parameters(st->codec))
1881                 break;
1882             /* variable fps and no guess at the real fps */
1883             if(   tb_unreliable(st->codec)
1884                && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1885                 break;
1886             if(st->parser && st->parser->parser->split && !st->codec->extradata)
1887                 break;
1888             if(st->first_dts == AV_NOPTS_VALUE)
1889                 break;
1890         }
1891         if (i == ic->nb_streams) {
1892             /* NOTE: if the format has no header, then we need to read
1893                some packets to get most of the streams, so we cannot
1894                stop here */
1895             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1896                 /* if we found the info for all the codecs, we can stop */
1897                 ret = count;
1898                 break;
1899             }
1900         }
1901         /* we did not get all the codec info, but we read too much data */
1902         if (read_size >= MAX_READ_SIZE) {
1903             ret = count;
1904             break;
1905         }
1906
1907         /* NOTE: a new stream can be added there if no header in file
1908            (AVFMTCTX_NOHEADER) */
1909         ret = av_read_frame_internal(ic, &pkt1);
1910         if (ret < 0) {
1911             /* EOF or error */
1912             ret = -1; /* we could not have all the codec parameters before EOF */
1913             for(i=0;i<ic->nb_streams;i++) {
1914                 st = ic->streams[i];
1915                 if (!has_codec_parameters(st->codec)){
1916                     char buf[256];
1917                     avcodec_string(buf, sizeof(buf), st->codec, 0);
1918                     av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1919                 } else {
1920                     ret = 0;
1921                 }
1922             }
1923             break;
1924         }
1925
1926         pkt= add_to_pktbuf(ic, &pkt1);
1927         if(av_dup_packet(pkt) < 0)
1928             return AVERROR(ENOMEM);
1929
1930         read_size += pkt->size;
1931
1932         st = ic->streams[pkt->stream_index];
1933         if(codec_info_nb_frames[st->index]>1)
1934             codec_info_duration[st->index] += pkt->duration;
1935         if (pkt->duration != 0)
1936             codec_info_nb_frames[st->index]++;
1937
1938         {
1939             int index= pkt->stream_index;
1940             int64_t last= last_dts[index];
1941             int64_t duration= pkt->dts - last;
1942
1943             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1944                 double dur= duration * av_q2d(st->time_base);
1945
1946 //                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1947 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1948                 if(duration_count[index] < 2)
1949                     memset(duration_error[index], 0, sizeof(*duration_error));
1950                 for(i=1; i<MAX_STD_TIMEBASES; i++){
1951                     int framerate= get_std_framerate(i);
1952                     int ticks= lrintf(dur*framerate/(1001*12));
1953                     double error= dur - ticks*1001*12/(double)framerate;
1954                     duration_error[index][i] += error*error;
1955                 }
1956                 duration_count[index]++;
1957             }
1958             if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1959                 last_dts[pkt->stream_index]= pkt->dts;
1960
1961             if (st->codec->codec_id == CODEC_ID_NONE) {
1962                 AVProbeData *pd = &(probe_data[st->index]);
1963                 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
1964                 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1965                 pd->buf_size += pkt->size;
1966                 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
1967             }
1968         }
1969         if(st->parser && st->parser->parser->split && !st->codec->extradata){
1970             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1971             if(i){
1972                 st->codec->extradata_size= i;
1973                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1974                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1975                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1976             }
1977         }
1978
1979         /* if still no information, we try to open the codec and to
1980            decompress the frame. We try to avoid that in most cases as
1981            it takes longer and uses more memory. For MPEG-4, we need to
1982            decompress for QuickTime. */
1983         if (!has_codec_parameters(st->codec) /*&&
1984             (st->codec->codec_id == CODEC_ID_FLV1 ||
1985              st->codec->codec_id == CODEC_ID_H264 ||
1986              st->codec->codec_id == CODEC_ID_H263 ||
1987              st->codec->codec_id == CODEC_ID_H261 ||
1988              st->codec->codec_id == CODEC_ID_VORBIS ||
1989              st->codec->codec_id == CODEC_ID_MJPEG ||
1990              st->codec->codec_id == CODEC_ID_PNG ||
1991              st->codec->codec_id == CODEC_ID_PAM ||
1992              st->codec->codec_id == CODEC_ID_PGM ||
1993              st->codec->codec_id == CODEC_ID_PGMYUV ||
1994              st->codec->codec_id == CODEC_ID_PBM ||
1995              st->codec->codec_id == CODEC_ID_PPM ||
1996              st->codec->codec_id == CODEC_ID_SHORTEN ||
1997              (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1998             try_decode_frame(st, pkt->data, pkt->size);
1999
2000         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) {
2001             break;
2002         }
2003         count++;
2004     }
2005
2006     // close codecs which were opened in try_decode_frame()
2007     for(i=0;i<ic->nb_streams;i++) {
2008         st = ic->streams[i];
2009         if(st->codec->codec)
2010             avcodec_close(st->codec);
2011     }
2012     for(i=0;i<ic->nb_streams;i++) {
2013         st = ic->streams[i];
2014         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2015             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
2016                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2017
2018             if(duration_count[i]
2019                && tb_unreliable(st->codec) /*&&
2020                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2021                st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2022                 double best_error= 2*av_q2d(st->time_base);
2023                 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2024
2025                 for(j=1; j<MAX_STD_TIMEBASES; j++){
2026                     double error= duration_error[i][j] * get_std_framerate(j);
2027 //                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2028 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2029                     if(error < best_error){
2030                         best_error= error;
2031                         av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
2032                     }
2033                 }
2034             }
2035
2036             if (!st->r_frame_rate.num){
2037                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2038                     <= st->codec->time_base.num * (int64_t)st->time_base.den){
2039                     st->r_frame_rate.num = st->codec->time_base.den;
2040                     st->r_frame_rate.den = st->codec->time_base.num;
2041                 }else{
2042                     st->r_frame_rate.num = st->time_base.den;
2043                     st->r_frame_rate.den = st->time_base.num;
2044                 }
2045             }
2046         }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2047             if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
2048                 codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
2049                 if (codec_identified[st->index]) {
2050                     st->need_parsing = AVSTREAM_PARSE_FULL;
2051                 }
2052             }
2053             if(!st->codec->bits_per_sample)
2054                 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
2055         }
2056     }
2057
2058     av_estimate_timings(ic, old_offset);
2059
2060     for(i=0;i<ic->nb_streams;i++) {
2061         st = ic->streams[i];
2062         if (codec_identified[st->index])
2063             break;
2064     }
2065     //FIXME this is a mess
2066     if(i!=ic->nb_streams){
2067         av_read_frame_flush(ic);
2068         for(i=0;i<ic->nb_streams;i++) {
2069             st = ic->streams[i];
2070             if (codec_identified[st->index]) {
2071                 av_seek_frame(ic, st->index, 0.0, 0);
2072             }
2073             st->cur_dts= st->first_dts;
2074         }
2075         url_fseek(ic->pb, ic->data_offset, SEEK_SET);
2076     }
2077
2078 #if 0
2079     /* correct DTS for B-frame streams with no timestamps */
2080     for(i=0;i<ic->nb_streams;i++) {
2081         st = ic->streams[i];
2082         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2083             if(b-frames){
2084                 ppktl = &ic->packet_buffer;
2085                 while(ppkt1){
2086                     if(ppkt1->stream_index != i)
2087                         continue;
2088                     if(ppkt1->pkt->dts < 0)
2089                         break;
2090                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2091                         break;
2092                     ppkt1->pkt->dts -= delta;
2093                     ppkt1= ppkt1->next;
2094                 }
2095                 if(ppkt1)
2096                     continue;
2097                 st->cur_dts -= delta;
2098             }
2099         }
2100     }
2101 #endif
2102
2103     av_free(duration_error);
2104     for(i=0;i<MAX_STREAMS;i++){
2105         av_freep(&(probe_data[i].buf));
2106     }
2107
2108     return ret;
2109 }
2110
2111 /*******************************************************/
2112
2113 int av_read_play(AVFormatContext *s)
2114 {
2115     if (s->iformat->read_play)
2116         return s->iformat->read_play(s);
2117     if (s->pb)
2118         return av_url_read_fpause(s->pb, 0);
2119     return AVERROR(ENOSYS);
2120 }
2121
2122 int av_read_pause(AVFormatContext *s)
2123 {
2124     if (s->iformat->read_pause)
2125         return s->iformat->read_pause(s);
2126     if (s->pb)
2127         return av_url_read_fpause(s->pb, 1);
2128     return AVERROR(ENOSYS);
2129 }
2130
2131 void av_close_input_stream(AVFormatContext *s)
2132 {
2133     int i;
2134     AVStream *st;
2135
2136     /* free previous packet */
2137     if (s->cur_st && s->cur_st->parser)
2138         av_free_packet(&s->cur_pkt);
2139
2140     if (s->iformat->read_close)
2141         s->iformat->read_close(s);
2142     for(i=0;i<s->nb_streams;i++) {
2143         /* free all data in a stream component */
2144         st = s->streams[i];
2145         if (st->parser) {
2146             av_parser_close(st->parser);
2147         }
2148         av_free(st->index_entries);
2149         av_free(st->codec->extradata);
2150         av_free(st->codec);
2151         av_free(st->filename);
2152         av_free(st);
2153     }
2154     for(i=s->nb_programs-1; i>=0; i--) {
2155         av_freep(&s->programs[i]->provider_name);
2156         av_freep(&s->programs[i]->name);
2157         av_freep(&s->programs[i]->stream_index);
2158         av_freep(&s->programs[i]);
2159     }
2160     av_freep(&s->programs);
2161     flush_packet_queue(s);
2162     av_freep(&s->priv_data);
2163     while(s->nb_chapters--) {
2164         av_free(s->chapters[s->nb_chapters]->title);
2165         av_free(s->chapters[s->nb_chapters]);
2166     }
2167     av_freep(&s->chapters);
2168     av_free(s);
2169 }
2170
2171 void av_close_input_file(AVFormatContext *s)
2172 {
2173     ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2174     av_close_input_stream(s);
2175     if (pb)
2176         url_fclose(pb);
2177 }
2178
2179 AVStream *av_new_stream(AVFormatContext *s, int id)
2180 {
2181     AVStream *st;
2182     int i;
2183
2184     if (s->nb_streams >= MAX_STREAMS)
2185         return NULL;
2186
2187     st = av_mallocz(sizeof(AVStream));
2188     if (!st)
2189         return NULL;
2190
2191     st->codec= avcodec_alloc_context();
2192     if (s->iformat) {
2193         /* no default bitrate if decoding */
2194         st->codec->bit_rate = 0;
2195     }
2196     st->index = s->nb_streams;
2197     st->id = id;
2198     st->start_time = AV_NOPTS_VALUE;
2199     st->duration = AV_NOPTS_VALUE;
2200     st->cur_dts = AV_NOPTS_VALUE;
2201     st->first_dts = AV_NOPTS_VALUE;
2202
2203     /* default pts setting is MPEG-like */
2204     av_set_pts_info(st, 33, 1, 90000);
2205     st->last_IP_pts = AV_NOPTS_VALUE;
2206     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2207         st->pts_buffer[i]= AV_NOPTS_VALUE;
2208
2209     s->streams[s->nb_streams++] = st;
2210     return st;
2211 }
2212
2213 AVProgram *av_new_program(AVFormatContext *ac, int id)
2214 {
2215     AVProgram *program=NULL;
2216     int i;
2217
2218 #ifdef DEBUG_SI
2219     av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2220 #endif
2221
2222     for(i=0; i<ac->nb_programs; i++)
2223         if(ac->programs[i]->id == id)
2224             program = ac->programs[i];
2225
2226     if(!program){
2227         program = av_mallocz(sizeof(AVProgram));
2228         if (!program)
2229             return NULL;
2230         dynarray_add(&ac->programs, &ac->nb_programs, program);
2231         program->discard = AVDISCARD_NONE;
2232     }
2233     program->id = id;
2234
2235     return program;
2236 }
2237
2238 void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2239 {
2240     assert(!provider_name == !name);
2241     if(name){
2242         av_free(program->provider_name);
2243         av_free(program->         name);
2244         program->provider_name = av_strdup(provider_name);
2245         program->         name = av_strdup(         name);
2246     }
2247 }
2248
2249 AVChapter *ff_new_chapter(AVFormatContext *s, int id, int64_t start, int64_t end, const char *title)
2250 {
2251     AVChapter *chapter = NULL;
2252     int i;
2253
2254     for(i=0; i<s->nb_chapters; i++)
2255         if(s->chapters[i]->id == id)
2256             chapter = s->chapters[i];
2257
2258     if(!chapter){
2259         chapter= av_mallocz(sizeof(AVChapter));
2260         if(!chapter)
2261             return NULL;
2262         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2263     }
2264     if(chapter->title)
2265         av_free(chapter->title);
2266     chapter->title = av_strdup(title);
2267     chapter->id    = id;
2268     chapter->start = start;
2269     chapter->end   = end;
2270
2271     return chapter;
2272 }
2273
2274 /************************************************************/
2275 /* output media file */
2276
2277 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2278 {
2279     int ret;
2280
2281     if (s->oformat->priv_data_size > 0) {
2282         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2283         if (!s->priv_data)
2284             return AVERROR(ENOMEM);
2285     } else
2286         s->priv_data = NULL;
2287
2288     if (s->oformat->set_parameters) {
2289         ret = s->oformat->set_parameters(s, ap);
2290         if (ret < 0)
2291             return ret;
2292     }
2293     return 0;
2294 }
2295
2296 int av_write_header(AVFormatContext *s)
2297 {
2298     int ret, i;
2299     AVStream *st;
2300
2301     // some sanity checks
2302     for(i=0;i<s->nb_streams;i++) {
2303         st = s->streams[i];
2304
2305         switch (st->codec->codec_type) {
2306         case CODEC_TYPE_AUDIO:
2307             if(st->codec->sample_rate<=0){
2308                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2309                 return -1;
2310             }
2311             break;
2312         case CODEC_TYPE_VIDEO:
2313             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2314                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2315                 return -1;
2316             }
2317             if(st->codec->width<=0 || st->codec->height<=0){
2318                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2319                 return -1;
2320             }
2321             break;
2322         }
2323
2324         if(s->oformat->codec_tag){
2325             if(st->codec->codec_tag){
2326                 //FIXME
2327                 //check that tag + id is in the table
2328                 //if neither is in the table -> OK
2329                 //if tag is in the table with another id -> FAIL
2330                 //if id is in the table with another tag -> FAIL unless strict < ?
2331             }else
2332                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2333         }
2334     }
2335
2336     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2337         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2338         if (!s->priv_data)
2339             return AVERROR(ENOMEM);
2340     }
2341
2342     if(s->oformat->write_header){
2343         ret = s->oformat->write_header(s);
2344         if (ret < 0)
2345             return ret;
2346     }
2347
2348     /* init PTS generation */
2349     for(i=0;i<s->nb_streams;i++) {
2350         int64_t den = AV_NOPTS_VALUE;
2351         st = s->streams[i];
2352
2353         switch (st->codec->codec_type) {
2354         case CODEC_TYPE_AUDIO:
2355             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2356             break;
2357         case CODEC_TYPE_VIDEO:
2358             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2359             break;
2360         default:
2361             break;
2362         }
2363         if (den != AV_NOPTS_VALUE) {
2364             if (den <= 0)
2365                 return AVERROR_INVALIDDATA;
2366             av_frac_init(&st->pts, 0, 0, den);
2367         }
2368     }
2369     return 0;
2370 }
2371
2372 //FIXME merge with compute_pkt_fields
2373 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2374     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2375     int num, den, frame_size, i;
2376
2377 //    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);
2378
2379 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2380         return -1;*/
2381
2382     /* duration field */
2383     if (pkt->duration == 0) {
2384         compute_frame_duration(&num, &den, st, NULL, pkt);
2385         if (den && num) {
2386             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2387         }
2388     }
2389
2390     //XXX/FIXME this is a temporary hack until all encoders output pts
2391     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2392         pkt->dts=
2393 //        pkt->pts= st->cur_dts;
2394         pkt->pts= st->pts.val;
2395     }
2396
2397     //calculate dts from pts
2398     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2399         st->pts_buffer[0]= pkt->pts;
2400         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2401             st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2402         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2403             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2404
2405         pkt->dts= st->pts_buffer[0];
2406     }
2407
2408     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2409         av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2410         return -1;
2411     }
2412     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2413         av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2414         return -1;
2415     }
2416
2417 //    av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2418     st->cur_dts= pkt->dts;
2419     st->pts.val= pkt->dts;
2420
2421     /* update pts */
2422     switch (st->codec->codec_type) {
2423     case CODEC_TYPE_AUDIO:
2424         frame_size = get_audio_frame_size(st->codec, pkt->size);
2425
2426         /* HACK/FIXME, we skip the initial 0 size packets as they are most
2427            likely equal to the encoder delay, but it would be better if we
2428            had the real timestamps from the encoder */
2429         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2430             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2431         }
2432         break;
2433     case CODEC_TYPE_VIDEO:
2434         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2435         break;
2436     default:
2437         break;
2438     }
2439     return 0;
2440 }
2441
2442 static void truncate_ts(AVStream *st, AVPacket *pkt){
2443     int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2444
2445 //    if(pkt->dts < 0)
2446 //        pkt->dts= 0;  //this happens for low_delay=0 and B-frames, FIXME, needs further investigation about what we should do here
2447
2448     if (pkt->pts != AV_NOPTS_VALUE)
2449         pkt->pts &= pts_mask;
2450     if (pkt->dts != AV_NOPTS_VALUE)
2451         pkt->dts &= pts_mask;
2452 }
2453
2454 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2455 {
2456     int ret;
2457
2458     ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2459     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2460         return ret;
2461
2462     truncate_ts(s->streams[pkt->stream_index], pkt);
2463
2464     ret= s->oformat->write_packet(s, pkt);
2465     if(!ret)
2466         ret= url_ferror(s->pb);
2467     return ret;
2468 }
2469
2470 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2471     AVPacketList *pktl, **next_point, *this_pktl;
2472     int stream_count=0;
2473     int streams[MAX_STREAMS];
2474
2475     if(pkt){
2476         AVStream *st= s->streams[ pkt->stream_index];
2477
2478 //        assert(pkt->destruct != av_destruct_packet); //FIXME
2479
2480         this_pktl = av_mallocz(sizeof(AVPacketList));
2481         this_pktl->pkt= *pkt;
2482         if(pkt->destruct == av_destruct_packet)
2483             pkt->destruct= NULL; // not shared -> must keep original from being freed
2484         else
2485             av_dup_packet(&this_pktl->pkt);  //shared -> must dup
2486
2487         next_point = &s->packet_buffer;
2488         while(*next_point){
2489             AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2490             int64_t left=  st2->time_base.num * (int64_t)st ->time_base.den;
2491             int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2492             if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2493                 break;
2494             next_point= &(*next_point)->next;
2495         }
2496         this_pktl->next= *next_point;
2497         *next_point= this_pktl;
2498     }
2499
2500     memset(streams, 0, sizeof(streams));
2501     pktl= s->packet_buffer;
2502     while(pktl){
2503 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2504         if(streams[ pktl->pkt.stream_index ] == 0)
2505             stream_count++;
2506         streams[ pktl->pkt.stream_index ]++;
2507         pktl= pktl->next;
2508     }
2509
2510     if(s->nb_streams == stream_count || (flush && stream_count)){
2511         pktl= s->packet_buffer;
2512         *out= pktl->pkt;
2513
2514         s->packet_buffer= pktl->next;
2515         av_freep(&pktl);
2516         return 1;
2517     }else{
2518         av_init_packet(out);
2519         return 0;
2520     }
2521 }
2522
2523 /**
2524  * Interleaves an AVPacket correctly so it can be muxed.
2525  * @param out the interleaved packet will be output here
2526  * @param in the input packet
2527  * @param flush 1 if no further packets are available as input and all
2528  *              remaining packets should be output
2529  * @return 1 if a packet was output, 0 if no packet could be output,
2530  *         < 0 if an error occurred
2531  */
2532 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2533     if(s->oformat->interleave_packet)
2534         return s->oformat->interleave_packet(s, out, in, flush);
2535     else
2536         return av_interleave_packet_per_dts(s, out, in, flush);
2537 }
2538
2539 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2540     AVStream *st= s->streams[ pkt->stream_index];
2541
2542     //FIXME/XXX/HACK drop zero sized packets
2543     if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2544         return 0;
2545
2546 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2547     if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2548         return -1;
2549
2550     if(pkt->dts == AV_NOPTS_VALUE)
2551         return -1;
2552
2553     for(;;){
2554         AVPacket opkt;
2555         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2556         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2557             return ret;
2558
2559         truncate_ts(s->streams[opkt.stream_index], &opkt);
2560         ret= s->oformat->write_packet(s, &opkt);
2561
2562         av_free_packet(&opkt);
2563         pkt= NULL;
2564
2565         if(ret<0)
2566             return ret;
2567         if(url_ferror(s->pb))
2568             return url_ferror(s->pb);
2569     }
2570 }
2571
2572 int av_write_trailer(AVFormatContext *s)
2573 {
2574     int ret, i;
2575
2576     for(;;){
2577         AVPacket pkt;
2578         ret= av_interleave_packet(s, &pkt, NULL, 1);
2579         if(ret<0) //FIXME cleanup needed for ret<0 ?
2580             goto fail;
2581         if(!ret)
2582             break;
2583
2584         truncate_ts(s->streams[pkt.stream_index], &pkt);
2585         ret= s->oformat->write_packet(s, &pkt);
2586
2587         av_free_packet(&pkt);
2588
2589         if(ret<0)
2590             goto fail;
2591         if(url_ferror(s->pb))
2592             goto fail;
2593     }
2594
2595     if(s->oformat->write_trailer)
2596         ret = s->oformat->write_trailer(s);
2597 fail:
2598     if(ret == 0)
2599        ret=url_ferror(s->pb);
2600     for(i=0;i<s->nb_streams;i++)
2601         av_freep(&s->streams[i]->priv_data);
2602     av_freep(&s->priv_data);
2603     return ret;
2604 }
2605
2606 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2607 {
2608     int i, j;
2609     AVProgram *program=NULL;
2610     void *tmp;
2611
2612     for(i=0; i<ac->nb_programs; i++){
2613         if(ac->programs[i]->id != progid)
2614             continue;
2615         program = ac->programs[i];
2616         for(j=0; j<program->nb_stream_indexes; j++)
2617             if(program->stream_index[j] == idx)
2618                 return;
2619
2620         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2621         if(!tmp)
2622             return;
2623         program->stream_index = tmp;
2624         program->stream_index[program->nb_stream_indexes++] = idx;
2625         return;
2626     }
2627 }
2628
2629 /* "user interface" functions */
2630 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2631 {
2632     char buf[256];
2633     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2634     AVStream *st = ic->streams[i];
2635     int g = ff_gcd(st->time_base.num, st->time_base.den);
2636     avcodec_string(buf, sizeof(buf), st->codec, is_output);
2637     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2638     /* the pid is an important information, so we display it */
2639     /* XXX: add a generic system */
2640     if (flags & AVFMT_SHOW_IDS)
2641         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2642     if (strlen(st->language) > 0)
2643         av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2644     av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2645     av_log(NULL, AV_LOG_INFO, ": %s", buf);
2646     if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2647         if(st->r_frame_rate.den && st->r_frame_rate.num)
2648             av_log(NULL, AV_LOG_INFO, ", %5.2f tb(r)", av_q2d(st->r_frame_rate));
2649 /*      else if(st->time_base.den && st->time_base.num)
2650             av_log(NULL, AV_LOG_INFO, ", %5.2f tb(m)", 1/av_q2d(st->time_base));*/
2651         else
2652             av_log(NULL, AV_LOG_INFO, ", %5.2f tb(c)", 1/av_q2d(st->codec->time_base));
2653     }
2654     av_log(NULL, AV_LOG_INFO, "\n");
2655 }
2656
2657 void dump_format(AVFormatContext *ic,
2658                  int index,
2659                  const char *url,
2660                  int is_output)
2661 {
2662     int i;
2663
2664     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2665             is_output ? "Output" : "Input",
2666             index,
2667             is_output ? ic->oformat->name : ic->iformat->name,
2668             is_output ? "to" : "from", url);
2669     if (!is_output) {
2670         av_log(NULL, AV_LOG_INFO, "  Duration: ");
2671         if (ic->duration != AV_NOPTS_VALUE) {
2672             int hours, mins, secs, us;
2673             secs = ic->duration / AV_TIME_BASE;
2674             us = ic->duration % AV_TIME_BASE;
2675             mins = secs / 60;
2676             secs %= 60;
2677             hours = mins / 60;
2678             mins %= 60;
2679             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2680                    (100 * us) / AV_TIME_BASE);
2681         } else {
2682             av_log(NULL, AV_LOG_INFO, "N/A");
2683         }
2684         if (ic->start_time != AV_NOPTS_VALUE) {
2685             int secs, us;
2686             av_log(NULL, AV_LOG_INFO, ", start: ");
2687             secs = ic->start_time / AV_TIME_BASE;
2688             us = ic->start_time % AV_TIME_BASE;
2689             av_log(NULL, AV_LOG_INFO, "%d.%06d",
2690                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2691         }
2692         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2693         if (ic->bit_rate) {
2694             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2695         } else {
2696             av_log(NULL, AV_LOG_INFO, "N/A");
2697         }
2698         av_log(NULL, AV_LOG_INFO, "\n");
2699     }
2700     if(ic->nb_programs) {
2701         int j, k;
2702         for(j=0; j<ic->nb_programs; j++) {
2703             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2704                    ic->programs[j]->name ? ic->programs[j]->name : "");
2705             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2706                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2707          }
2708     } else
2709     for(i=0;i<ic->nb_streams;i++)
2710         dump_stream_format(ic, i, index, is_output);
2711 }
2712
2713 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2714 {
2715     return av_parse_video_frame_size(width_ptr, height_ptr, str);
2716 }
2717
2718 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2719 {
2720     AVRational frame_rate;
2721     int ret = av_parse_video_frame_rate(&frame_rate, arg);
2722     *frame_rate_num= frame_rate.num;
2723     *frame_rate_den= frame_rate.den;
2724     return ret;
2725 }
2726
2727 /**
2728  * Gets the current time in microseconds.
2729  */
2730 int64_t av_gettime(void)
2731 {
2732     struct timeval tv;
2733     gettimeofday(&tv,NULL);
2734     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2735 }
2736
2737 int64_t parse_date(const char *datestr, int duration)
2738 {
2739     const char *p;
2740     int64_t t;
2741     struct tm dt;
2742     int i;
2743     static const char *date_fmt[] = {
2744         "%Y-%m-%d",
2745         "%Y%m%d",
2746     };
2747     static const char *time_fmt[] = {
2748         "%H:%M:%S",
2749         "%H%M%S",
2750     };
2751     const char *q;
2752     int is_utc, len;
2753     char lastch;
2754     int negative = 0;
2755
2756 #undef time
2757     time_t now = time(0);
2758
2759     len = strlen(datestr);
2760     if (len > 0)
2761         lastch = datestr[len - 1];
2762     else
2763         lastch = '\0';
2764     is_utc = (lastch == 'z' || lastch == 'Z');
2765
2766     memset(&dt, 0, sizeof(dt));
2767
2768     p = datestr;
2769     q = NULL;
2770     if (!duration) {
2771         /* parse the year-month-day part */
2772         for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2773             q = small_strptime(p, date_fmt[i], &dt);
2774             if (q) {
2775                 break;
2776             }
2777         }
2778
2779         /* if the year-month-day part is missing, then take the
2780          * current year-month-day time */
2781         if (!q) {
2782             if (is_utc) {
2783                 dt = *gmtime(&now);
2784             } else {
2785                 dt = *localtime(&now);
2786             }
2787             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2788         } else {
2789             p = q;
2790         }
2791
2792         if (*p == 'T' || *p == 't' || *p == ' ')
2793             p++;
2794
2795         /* parse the hour-minute-second part */
2796         for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2797             q = small_strptime(p, time_fmt[i], &dt);
2798             if (q) {
2799                 break;
2800             }
2801         }
2802     } else {
2803         /* parse datestr as a duration */
2804         if (p[0] == '-') {
2805             negative = 1;
2806             ++p;
2807         }
2808         /* parse datestr as HH:MM:SS */
2809         q = small_strptime(p, time_fmt[0], &dt);
2810         if (!q) {
2811             /* parse datestr as S+ */
2812             dt.tm_sec = strtol(p, (char **)&q, 10);
2813             if (q == p)
2814                 /* the parsing didn't succeed */
2815                 return INT64_MIN;
2816             dt.tm_min = 0;
2817             dt.tm_hour = 0;
2818         }
2819     }
2820
2821     /* Now we have all the fields that we can get */
2822     if (!q) {
2823         return INT64_MIN;
2824     }
2825
2826     if (duration) {
2827         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2828     } else {
2829         dt.tm_isdst = -1;       /* unknown */
2830         if (is_utc) {
2831             t = mktimegm(&dt);
2832         } else {
2833             t = mktime(&dt);
2834         }
2835     }
2836
2837     t *= 1000000;
2838
2839     /* parse the .m... part */
2840     if (*q == '.') {
2841         int val, n;
2842         q++;
2843         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2844             if (!isdigit(*q))
2845                 break;
2846             val += n * (*q - '0');
2847         }
2848         t += val;
2849     }
2850     return negative ? -t : t;
2851 }
2852
2853 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2854 {
2855     const char *p;
2856     char tag[128], *q;
2857
2858     p = info;
2859     if (*p == '?')
2860         p++;
2861     for(;;) {
2862         q = tag;
2863         while (*p != '\0' && *p != '=' && *p != '&') {
2864             if ((q - tag) < sizeof(tag) - 1)
2865                 *q++ = *p;
2866             p++;
2867         }
2868         *q = '\0';
2869         q = arg;
2870         if (*p == '=') {
2871             p++;
2872             while (*p != '&' && *p != '\0') {
2873                 if ((q - arg) < arg_size - 1) {
2874                     if (*p == '+')
2875                         *q++ = ' ';
2876                     else
2877                         *q++ = *p;
2878                 }
2879                 p++;
2880             }
2881             *q = '\0';
2882         }
2883         if (!strcmp(tag, tag1))
2884             return 1;
2885         if (*p != '&')
2886             break;
2887         p++;
2888     }
2889     return 0;
2890 }
2891
2892 int av_get_frame_filename(char *buf, int buf_size,
2893                           const char *path, int number)
2894 {
2895     const char *p;
2896     char *q, buf1[20], c;
2897     int nd, len, percentd_found;
2898
2899     q = buf;
2900     p = path;
2901     percentd_found = 0;
2902     for(;;) {
2903         c = *p++;
2904         if (c == '\0')
2905             break;
2906         if (c == '%') {
2907             do {
2908                 nd = 0;
2909                 while (isdigit(*p)) {
2910                     nd = nd * 10 + *p++ - '0';
2911                 }
2912                 c = *p++;
2913             } while (isdigit(c));
2914
2915             switch(c) {
2916             case '%':
2917                 goto addchar;
2918             case 'd':
2919                 if (percentd_found)
2920                     goto fail;
2921                 percentd_found = 1;
2922                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2923                 len = strlen(buf1);
2924                 if ((q - buf + len) > buf_size - 1)
2925                     goto fail;
2926                 memcpy(q, buf1, len);
2927                 q += len;
2928                 break;
2929             default:
2930                 goto fail;
2931             }
2932         } else {
2933         addchar:
2934             if ((q - buf) < buf_size - 1)
2935                 *q++ = c;
2936         }
2937     }
2938     if (!percentd_found)
2939         goto fail;
2940     *q = '\0';
2941     return 0;
2942  fail:
2943     *q = '\0';
2944     return -1;
2945 }
2946
2947 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2948 {
2949     int len, i, j, c;
2950 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2951
2952     for(i=0;i<size;i+=16) {
2953         len = size - i;
2954         if (len > 16)
2955             len = 16;
2956         PRINT("%08x ", i);
2957         for(j=0;j<16;j++) {
2958             if (j < len)
2959                 PRINT(" %02x", buf[i+j]);
2960             else
2961                 PRINT("   ");
2962         }
2963         PRINT(" ");
2964         for(j=0;j<len;j++) {
2965             c = buf[i+j];
2966             if (c < ' ' || c > '~')
2967                 c = '.';
2968             PRINT("%c", c);
2969         }
2970         PRINT("\n");
2971     }
2972 #undef PRINT
2973 }
2974
2975 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2976 {
2977     hex_dump_internal(NULL, f, 0, buf, size);
2978 }
2979
2980 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2981 {
2982     hex_dump_internal(avcl, NULL, level, buf, size);
2983 }
2984
2985  //FIXME needs to know the time_base
2986 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2987 {
2988 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2989     PRINT("stream #%d:\n", pkt->stream_index);
2990     PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2991     PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2992     /* DTS is _always_ valid after av_read_frame() */
2993     PRINT("  dts=");
2994     if (pkt->dts == AV_NOPTS_VALUE)
2995         PRINT("N/A");
2996     else
2997         PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2998     /* PTS may not be known if B-frames are present. */
2999     PRINT("  pts=");
3000     if (pkt->pts == AV_NOPTS_VALUE)
3001         PRINT("N/A");
3002     else
3003         PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3004     PRINT("\n");
3005     PRINT("  size=%d\n", pkt->size);
3006 #undef PRINT
3007     if (dump_payload)
3008         av_hex_dump(f, pkt->data, pkt->size);
3009 }
3010
3011 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3012 {
3013     pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3014 }
3015
3016 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3017 {
3018     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3019 }
3020
3021 void url_split(char *proto, int proto_size,
3022                char *authorization, int authorization_size,
3023                char *hostname, int hostname_size,
3024                int *port_ptr,
3025                char *path, int path_size,
3026                const char *url)
3027 {
3028     const char *p, *ls, *at, *col, *brk;
3029
3030     if (port_ptr)               *port_ptr = -1;
3031     if (proto_size > 0)         proto[0] = 0;
3032     if (authorization_size > 0) authorization[0] = 0;
3033     if (hostname_size > 0)      hostname[0] = 0;
3034     if (path_size > 0)          path[0] = 0;
3035
3036     /* parse protocol */
3037     if ((p = strchr(url, ':'))) {
3038         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3039         p++; /* skip ':' */
3040         if (*p == '/') p++;
3041         if (*p == '/') p++;
3042     } else {
3043         /* no protocol means plain filename */
3044         av_strlcpy(path, url, path_size);
3045         return;
3046     }
3047
3048     /* separate path from hostname */
3049     ls = strchr(p, '/');
3050     if(!ls)
3051         ls = strchr(p, '?');
3052     if(ls)
3053         av_strlcpy(path, ls, path_size);
3054     else
3055         ls = &p[strlen(p)]; // XXX
3056
3057     /* the rest is hostname, use that to parse auth/port */
3058     if (ls != p) {
3059         /* authorization (user[:pass]@hostname) */
3060         if ((at = strchr(p, '@')) && at < ls) {
3061             av_strlcpy(authorization, p,
3062                        FFMIN(authorization_size, at + 1 - p));
3063             p = at + 1; /* skip '@' */
3064         }
3065
3066         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3067             /* [host]:port */
3068             av_strlcpy(hostname, p + 1,
3069                        FFMIN(hostname_size, brk - p));
3070             if (brk[1] == ':' && port_ptr)
3071                 *port_ptr = atoi(brk + 2);
3072         } else if ((col = strchr(p, ':')) && col < ls) {
3073             av_strlcpy(hostname, p,
3074                        FFMIN(col + 1 - p, hostname_size));
3075             if (port_ptr) *port_ptr = atoi(col + 1);
3076         } else
3077             av_strlcpy(hostname, p,
3078                        FFMIN(ls + 1 - p, hostname_size));
3079     }
3080 }
3081
3082 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3083                      int pts_num, int pts_den)
3084 {
3085     s->pts_wrap_bits = pts_wrap_bits;
3086     s->time_base.num = pts_num;
3087     s->time_base.den = pts_den;
3088 }
3089
3090 /* fraction handling */
3091
3092 /**
3093  * f = val + (num / den) + 0.5.
3094  *
3095  * 'num' is normalized so that it is such as 0 <= num < den.
3096  *
3097  * @param f fractional number
3098  * @param val integer value
3099  * @param num must be >= 0
3100  * @param den must be >= 1
3101  */
3102 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
3103 {
3104     num += (den >> 1);
3105     if (num >= den) {
3106         val += num / den;
3107         num = num % den;
3108     }
3109     f->val = val;
3110     f->num = num;
3111     f->den = den;
3112 }
3113
3114 /**
3115  * Fractional addition to f: f = f + (incr / f->den).
3116  *
3117  * @param f fractional number
3118  * @param incr increment, can be positive or negative
3119  */
3120 static void av_frac_add(AVFrac *f, int64_t incr)
3121 {
3122     int64_t num, den;
3123
3124     num = f->num + incr;
3125     den = f->den;
3126     if (num < 0) {
3127         f->val += num / den;
3128         num = num % den;
3129         if (num < 0) {
3130             num += den;
3131             f->val--;
3132         }
3133     } else if (num >= den) {
3134         f->val += num / den;
3135         num = num % den;
3136     }
3137     f->num = num;
3138 }