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