64c5ec492bdf22d56c5fb790ffeb00d2d488ff28
[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                 if (st->duration == AV_NOPTS_VALUE ||
1828                     st->duration < duration)
1829                     st->duration = duration;
1830             }
1831         }
1832         av_free_packet(pkt);
1833     }
1834
1835     fill_all_stream_timings(ic);
1836
1837     url_fseek(ic->pb, old_offset, SEEK_SET);
1838     for(i=0; i<ic->nb_streams; i++){
1839         st= ic->streams[i];
1840         st->cur_dts= st->first_dts;
1841         st->last_IP_pts = AV_NOPTS_VALUE;
1842     }
1843 }
1844
1845 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1846 {
1847     int64_t file_size;
1848
1849     /* get the file size, if possible */
1850     if (ic->iformat->flags & AVFMT_NOFILE) {
1851         file_size = 0;
1852     } else {
1853         file_size = url_fsize(ic->pb);
1854         if (file_size < 0)
1855             file_size = 0;
1856     }
1857     ic->file_size = file_size;
1858
1859     if ((!strcmp(ic->iformat->name, "mpeg") ||
1860          !strcmp(ic->iformat->name, "mpegts")) &&
1861         file_size && !url_is_streamed(ic->pb)) {
1862         /* get accurate estimate from the PTSes */
1863         av_estimate_timings_from_pts(ic, old_offset);
1864     } else if (av_has_duration(ic)) {
1865         /* at least one component has timings - we use them for all
1866            the components */
1867         fill_all_stream_timings(ic);
1868     } else {
1869         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1870         /* less precise: use bitrate info */
1871         av_estimate_timings_from_bit_rate(ic);
1872     }
1873     av_update_stream_timings(ic);
1874
1875 #if 0
1876     {
1877         int i;
1878         AVStream *st;
1879         for(i = 0;i < ic->nb_streams; i++) {
1880             st = ic->streams[i];
1881         printf("%d: start_time: %0.3f duration: %0.3f\n",
1882                i, (double)st->start_time / AV_TIME_BASE,
1883                (double)st->duration / AV_TIME_BASE);
1884         }
1885         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1886                (double)ic->start_time / AV_TIME_BASE,
1887                (double)ic->duration / AV_TIME_BASE,
1888                ic->bit_rate / 1000);
1889     }
1890 #endif
1891 }
1892
1893 static int has_codec_parameters(AVCodecContext *enc)
1894 {
1895     int val;
1896     switch(enc->codec_type) {
1897     case CODEC_TYPE_AUDIO:
1898         val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1899         if(!enc->frame_size &&
1900            (enc->codec_id == CODEC_ID_VORBIS ||
1901             enc->codec_id == CODEC_ID_AAC ||
1902             enc->codec_id == CODEC_ID_MP3 ||
1903             enc->codec_id == CODEC_ID_SPEEX))
1904             return 0;
1905         break;
1906     case CODEC_TYPE_VIDEO:
1907         val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1908         break;
1909     default:
1910         val = 1;
1911         break;
1912     }
1913     return enc->codec_id != CODEC_ID_NONE && val != 0;
1914 }
1915
1916 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
1917 {
1918     int16_t *samples;
1919     AVCodec *codec;
1920     int got_picture, data_size, ret=0;
1921     AVFrame picture;
1922
1923     if(!st->codec->codec){
1924         codec = avcodec_find_decoder(st->codec->codec_id);
1925         if (!codec)
1926             return -1;
1927         ret = avcodec_open(st->codec, codec);
1928         if (ret < 0)
1929             return ret;
1930     }
1931
1932     if(!has_codec_parameters(st->codec)){
1933         switch(st->codec->codec_type) {
1934         case CODEC_TYPE_VIDEO:
1935             avcodec_get_frame_defaults(&picture);
1936             ret = avcodec_decode_video2(st->codec, &picture,
1937                                         &got_picture, avpkt);
1938             break;
1939         case CODEC_TYPE_AUDIO:
1940             data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1941             samples = av_malloc(data_size);
1942             if (!samples)
1943                 goto fail;
1944             ret = avcodec_decode_audio3(st->codec, samples,
1945                                         &data_size, avpkt);
1946             av_free(samples);
1947             break;
1948         default:
1949             break;
1950         }
1951     }
1952  fail:
1953     return ret;
1954 }
1955
1956 unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
1957 {
1958     while (tags->id != CODEC_ID_NONE) {
1959         if (tags->id == id)
1960             return tags->tag;
1961         tags++;
1962     }
1963     return 0;
1964 }
1965
1966 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
1967 {
1968     int i;
1969     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1970         if(tag == tags[i].tag)
1971             return tags[i].id;
1972     }
1973     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1974         if(   toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1975            && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1976            && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1977            && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1978             return tags[i].id;
1979     }
1980     return CODEC_ID_NONE;
1981 }
1982
1983 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
1984 {
1985     int i;
1986     for(i=0; tags && tags[i]; i++){
1987         int tag= ff_codec_get_tag(tags[i], id);
1988         if(tag) return tag;
1989     }
1990     return 0;
1991 }
1992
1993 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
1994 {
1995     int i;
1996     for(i=0; tags && tags[i]; i++){
1997         enum CodecID id= ff_codec_get_id(tags[i], tag);
1998         if(id!=CODEC_ID_NONE) return id;
1999     }
2000     return CODEC_ID_NONE;
2001 }
2002
2003 static void compute_chapters_end(AVFormatContext *s)
2004 {
2005     unsigned int i;
2006
2007     for (i=0; i+1<s->nb_chapters; i++)
2008         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2009             assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2010             assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2011             s->chapters[i]->end = s->chapters[i+1]->start;
2012         }
2013
2014     if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2015         assert(s->start_time != AV_NOPTS_VALUE);
2016         assert(s->duration > 0);
2017         s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2018                                            AV_TIME_BASE_Q,
2019                                            s->chapters[i]->time_base);
2020     }
2021 }
2022
2023 #define MAX_STD_TIMEBASES (60*12+5)
2024 static int get_std_framerate(int i){
2025     if(i<60*12) return i*1001;
2026     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2027 }
2028
2029 /*
2030  * Is the time base unreliable.
2031  * This is a heuristic to balance between quick acceptance of the values in
2032  * the headers vs. some extra checks.
2033  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2034  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2035  * And there are "variable" fps files this needs to detect as well.
2036  */
2037 static int tb_unreliable(AVCodecContext *c){
2038     if(   c->time_base.den >= 101L*c->time_base.num
2039        || c->time_base.den <    5L*c->time_base.num
2040 /*       || c->codec_tag == AV_RL32("DIVX")
2041        || c->codec_tag == AV_RL32("XVID")*/
2042        || c->codec_id == CODEC_ID_MPEG2VIDEO
2043        || c->codec_id == CODEC_ID_H264
2044        )
2045         return 1;
2046     return 0;
2047 }
2048
2049 int av_find_stream_info(AVFormatContext *ic)
2050 {
2051     int i, count, ret, read_size, j;
2052     AVStream *st;
2053     AVPacket pkt1, *pkt;
2054     int64_t last_dts[MAX_STREAMS];
2055     int64_t duration_gcd[MAX_STREAMS]={0};
2056     int duration_count[MAX_STREAMS]={0};
2057     double (*duration_error)[MAX_STD_TIMEBASES];
2058     int64_t old_offset = url_ftell(ic->pb);
2059     int64_t codec_info_duration[MAX_STREAMS]={0};
2060     int codec_info_nb_frames[MAX_STREAMS]={0};
2061
2062     duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2063     if (!duration_error) return AVERROR(ENOMEM);
2064
2065     for(i=0;i<ic->nb_streams;i++) {
2066         st = ic->streams[i];
2067         if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2068 /*            if(!st->time_base.num)
2069                 st->time_base= */
2070             if(!st->codec->time_base.num)
2071                 st->codec->time_base= st->time_base;
2072         }
2073         //only for the split stuff
2074         if (!st->parser) {
2075             st->parser = av_parser_init(st->codec->codec_id);
2076             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2077                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2078             }
2079         }
2080     }
2081
2082     for(i=0;i<MAX_STREAMS;i++){
2083         last_dts[i]= AV_NOPTS_VALUE;
2084     }
2085
2086     count = 0;
2087     read_size = 0;
2088     for(;;) {
2089         if(url_interrupt_cb()){
2090             ret= AVERROR(EINTR);
2091             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2092             break;
2093         }
2094
2095         /* check if one codec still needs to be handled */
2096         for(i=0;i<ic->nb_streams;i++) {
2097             st = ic->streams[i];
2098             if (!has_codec_parameters(st->codec))
2099                 break;
2100             /* variable fps and no guess at the real fps */
2101             if(   tb_unreliable(st->codec)
2102                && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
2103                 break;
2104             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2105                 break;
2106             if(st->first_dts == AV_NOPTS_VALUE)
2107                 break;
2108         }
2109         if (i == ic->nb_streams) {
2110             /* NOTE: if the format has no header, then we need to read
2111                some packets to get most of the streams, so we cannot
2112                stop here */
2113             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2114                 /* if we found the info for all the codecs, we can stop */
2115                 ret = count;
2116                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2117                 break;
2118             }
2119         }
2120         /* we did not get all the codec info, but we read too much data */
2121         if (read_size >= ic->probesize) {
2122             ret = count;
2123             av_log(ic, AV_LOG_WARNING, "MAX_READ_SIZE:%d reached\n", ic->probesize);
2124             break;
2125         }
2126
2127         /* NOTE: a new stream can be added there if no header in file
2128            (AVFMTCTX_NOHEADER) */
2129         ret = av_read_frame_internal(ic, &pkt1);
2130         if(ret == AVERROR(EAGAIN))
2131             continue;
2132         if (ret < 0) {
2133             /* EOF or error */
2134             ret = -1; /* we could not have all the codec parameters before EOF */
2135             for(i=0;i<ic->nb_streams;i++) {
2136                 st = ic->streams[i];
2137                 if (!has_codec_parameters(st->codec)){
2138                     char buf[256];
2139                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2140                     av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2141                 } else {
2142                     ret = 0;
2143                 }
2144             }
2145             break;
2146         }
2147
2148         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2149         if(av_dup_packet(pkt) < 0) {
2150             av_free(duration_error);
2151             return AVERROR(ENOMEM);
2152         }
2153
2154         read_size += pkt->size;
2155
2156         st = ic->streams[pkt->stream_index];
2157         if(codec_info_nb_frames[st->index]>1) {
2158             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){
2159                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2160                 break;
2161             }
2162             codec_info_duration[st->index] += pkt->duration;
2163         }
2164         if (pkt->duration != 0)
2165             codec_info_nb_frames[st->index]++;
2166
2167         {
2168             int index= pkt->stream_index;
2169             int64_t last= last_dts[index];
2170             int64_t duration= pkt->dts - last;
2171
2172             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2173                 double dur= duration * av_q2d(st->time_base);
2174
2175 //                if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2176 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2177                 if(duration_count[index] < 2)
2178                     memset(duration_error[index], 0, sizeof(*duration_error));
2179                 for(i=1; i<MAX_STD_TIMEBASES; i++){
2180                     int framerate= get_std_framerate(i);
2181                     int ticks= lrintf(dur*framerate/(1001*12));
2182                     double error= dur - ticks*1001*12/(double)framerate;
2183                     duration_error[index][i] += error*error;
2184                 }
2185                 duration_count[index]++;
2186                 // ignore the first 4 values, they might have some random jitter
2187                 if (duration_count[index] > 3)
2188                     duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2189             }
2190             if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2191                 last_dts[pkt->stream_index]= pkt->dts;
2192         }
2193         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2194             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2195             if(i){
2196                 st->codec->extradata_size= i;
2197                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2198                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2199                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2200             }
2201         }
2202
2203         /* if still no information, we try to open the codec and to
2204            decompress the frame. We try to avoid that in most cases as
2205            it takes longer and uses more memory. For MPEG-4, we need to
2206            decompress for QuickTime. */
2207         if (!has_codec_parameters(st->codec))
2208             try_decode_frame(st, pkt);
2209
2210         count++;
2211     }
2212
2213     // close codecs which were opened in try_decode_frame()
2214     for(i=0;i<ic->nb_streams;i++) {
2215         st = ic->streams[i];
2216         if(st->codec->codec)
2217             avcodec_close(st->codec);
2218     }
2219     for(i=0;i<ic->nb_streams;i++) {
2220         st = ic->streams[i];
2221         if(codec_info_nb_frames[i]>2 && !st->avg_frame_rate.num)
2222             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2223                      (codec_info_nb_frames[i]-2)*(int64_t)st->time_base.den,
2224                       codec_info_duration[i]    *(int64_t)st->time_base.num, 60000);
2225         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2226             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2227                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2228
2229             // the check for tb_unreliable() is not completely correct, since this is not about handling
2230             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2231             // ipmovie.c produces.
2232             if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1)
2233                 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);
2234             if(duration_count[i]
2235                && tb_unreliable(st->codec) /*&&
2236                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2237                st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2238                 int num = 0;
2239                 double best_error= 2*av_q2d(st->time_base);
2240                 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2241
2242                 for(j=1; j<MAX_STD_TIMEBASES; j++){
2243                     double error= duration_error[i][j] * get_std_framerate(j);
2244 //                    if(st->codec->codec_type == CODEC_TYPE_VIDEO)
2245 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2246                     if(error < best_error){
2247                         best_error= error;
2248                         num = get_std_framerate(j);
2249                     }
2250                 }
2251                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2252                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2253                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2254             }
2255
2256             if (!st->r_frame_rate.num){
2257                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2258                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2259                     st->r_frame_rate.num = st->codec->time_base.den;
2260                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2261                 }else{
2262                     st->r_frame_rate.num = st->time_base.den;
2263                     st->r_frame_rate.den = st->time_base.num;
2264                 }
2265             }
2266         }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
2267             if(!st->codec->bits_per_coded_sample)
2268                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2269         }
2270     }
2271
2272     av_estimate_timings(ic, old_offset);
2273
2274     compute_chapters_end(ic);
2275
2276 #if 0
2277     /* correct DTS for B-frame streams with no timestamps */
2278     for(i=0;i<ic->nb_streams;i++) {
2279         st = ic->streams[i];
2280         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2281             if(b-frames){
2282                 ppktl = &ic->packet_buffer;
2283                 while(ppkt1){
2284                     if(ppkt1->stream_index != i)
2285                         continue;
2286                     if(ppkt1->pkt->dts < 0)
2287                         break;
2288                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2289                         break;
2290                     ppkt1->pkt->dts -= delta;
2291                     ppkt1= ppkt1->next;
2292                 }
2293                 if(ppkt1)
2294                     continue;
2295                 st->cur_dts -= delta;
2296             }
2297         }
2298     }
2299 #endif
2300
2301     av_free(duration_error);
2302
2303     return ret;
2304 }
2305
2306 /*******************************************************/
2307
2308 int av_read_play(AVFormatContext *s)
2309 {
2310     if (s->iformat->read_play)
2311         return s->iformat->read_play(s);
2312     if (s->pb)
2313         return av_url_read_fpause(s->pb, 0);
2314     return AVERROR(ENOSYS);
2315 }
2316
2317 int av_read_pause(AVFormatContext *s)
2318 {
2319     if (s->iformat->read_pause)
2320         return s->iformat->read_pause(s);
2321     if (s->pb)
2322         return av_url_read_fpause(s->pb, 1);
2323     return AVERROR(ENOSYS);
2324 }
2325
2326 void av_close_input_stream(AVFormatContext *s)
2327 {
2328     int i;
2329     AVStream *st;
2330
2331     if (s->iformat->read_close)
2332         s->iformat->read_close(s);
2333     for(i=0;i<s->nb_streams;i++) {
2334         /* free all data in a stream component */
2335         st = s->streams[i];
2336         if (st->parser) {
2337             av_parser_close(st->parser);
2338             av_free_packet(&st->cur_pkt);
2339         }
2340         av_metadata_free(&st->metadata);
2341         av_free(st->index_entries);
2342         av_free(st->codec->extradata);
2343         av_free(st->codec);
2344 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2345         av_free(st->filename);
2346 #endif
2347         av_free(st->priv_data);
2348         av_free(st);
2349     }
2350     for(i=s->nb_programs-1; i>=0; i--) {
2351 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2352         av_freep(&s->programs[i]->provider_name);
2353         av_freep(&s->programs[i]->name);
2354 #endif
2355         av_metadata_free(&s->programs[i]->metadata);
2356         av_freep(&s->programs[i]->stream_index);
2357         av_freep(&s->programs[i]);
2358     }
2359     av_freep(&s->programs);
2360     flush_packet_queue(s);
2361     av_freep(&s->priv_data);
2362     while(s->nb_chapters--) {
2363 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2364         av_free(s->chapters[s->nb_chapters]->title);
2365 #endif
2366         av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2367         av_free(s->chapters[s->nb_chapters]);
2368     }
2369     av_freep(&s->chapters);
2370     av_metadata_free(&s->metadata);
2371     av_free(s);
2372 }
2373
2374 void av_close_input_file(AVFormatContext *s)
2375 {
2376     ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2377     av_close_input_stream(s);
2378     if (pb)
2379         url_fclose(pb);
2380 }
2381
2382 AVStream *av_new_stream(AVFormatContext *s, int id)
2383 {
2384     AVStream *st;
2385     int i;
2386
2387     if (s->nb_streams >= MAX_STREAMS)
2388         return NULL;
2389
2390     st = av_mallocz(sizeof(AVStream));
2391     if (!st)
2392         return NULL;
2393
2394     st->codec= avcodec_alloc_context();
2395     if (s->iformat) {
2396         /* no default bitrate if decoding */
2397         st->codec->bit_rate = 0;
2398     }
2399     st->index = s->nb_streams;
2400     st->id = id;
2401     st->start_time = AV_NOPTS_VALUE;
2402     st->duration = AV_NOPTS_VALUE;
2403         /* we set the current DTS to 0 so that formats without any timestamps
2404            but durations get some timestamps, formats with some unknown
2405            timestamps have their first few packets buffered and the
2406            timestamps corrected before they are returned to the user */
2407     st->cur_dts = 0;
2408     st->first_dts = AV_NOPTS_VALUE;
2409     st->probe_packets = MAX_PROBE_PACKETS;
2410
2411     /* default pts setting is MPEG-like */
2412     av_set_pts_info(st, 33, 1, 90000);
2413     st->last_IP_pts = AV_NOPTS_VALUE;
2414     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2415         st->pts_buffer[i]= AV_NOPTS_VALUE;
2416     st->reference_dts = AV_NOPTS_VALUE;
2417
2418     st->sample_aspect_ratio = (AVRational){0,1};
2419
2420     s->streams[s->nb_streams++] = st;
2421     return st;
2422 }
2423
2424 AVProgram *av_new_program(AVFormatContext *ac, int id)
2425 {
2426     AVProgram *program=NULL;
2427     int i;
2428
2429 #ifdef DEBUG_SI
2430     av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2431 #endif
2432
2433     for(i=0; i<ac->nb_programs; i++)
2434         if(ac->programs[i]->id == id)
2435             program = ac->programs[i];
2436
2437     if(!program){
2438         program = av_mallocz(sizeof(AVProgram));
2439         if (!program)
2440             return NULL;
2441         dynarray_add(&ac->programs, &ac->nb_programs, program);
2442         program->discard = AVDISCARD_NONE;
2443     }
2444     program->id = id;
2445
2446     return program;
2447 }
2448
2449 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2450 {
2451     AVChapter *chapter = NULL;
2452     int i;
2453
2454     for(i=0; i<s->nb_chapters; i++)
2455         if(s->chapters[i]->id == id)
2456             chapter = s->chapters[i];
2457
2458     if(!chapter){
2459         chapter= av_mallocz(sizeof(AVChapter));
2460         if(!chapter)
2461             return NULL;
2462         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2463     }
2464 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2465     av_free(chapter->title);
2466 #endif
2467     av_metadata_set(&chapter->metadata, "title", title);
2468     chapter->id    = id;
2469     chapter->time_base= time_base;
2470     chapter->start = start;
2471     chapter->end   = end;
2472
2473     return chapter;
2474 }
2475
2476 /************************************************************/
2477 /* output media file */
2478
2479 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2480 {
2481     int ret;
2482
2483     if (s->oformat->priv_data_size > 0) {
2484         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2485         if (!s->priv_data)
2486             return AVERROR(ENOMEM);
2487     } else
2488         s->priv_data = NULL;
2489
2490     if (s->oformat->set_parameters) {
2491         ret = s->oformat->set_parameters(s, ap);
2492         if (ret < 0)
2493             return ret;
2494     }
2495     return 0;
2496 }
2497
2498 int av_write_header(AVFormatContext *s)
2499 {
2500     int ret, i;
2501     AVStream *st;
2502
2503     // some sanity checks
2504     if (s->nb_streams == 0) {
2505         av_log(s, AV_LOG_ERROR, "no streams\n");
2506         return -1;
2507     }
2508
2509     for(i=0;i<s->nb_streams;i++) {
2510         st = s->streams[i];
2511
2512         switch (st->codec->codec_type) {
2513         case CODEC_TYPE_AUDIO:
2514             if(st->codec->sample_rate<=0){
2515                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2516                 return -1;
2517             }
2518             if(!st->codec->block_align)
2519                 st->codec->block_align = st->codec->channels *
2520                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2521             break;
2522         case CODEC_TYPE_VIDEO:
2523             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2524                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2525                 return -1;
2526             }
2527             if(st->codec->width<=0 || st->codec->height<=0){
2528                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2529                 return -1;
2530             }
2531             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2532                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2533                 return -1;
2534             }
2535             break;
2536         }
2537
2538         if(s->oformat->codec_tag){
2539             if(st->codec->codec_tag){
2540                 //FIXME
2541                 //check that tag + id is in the table
2542                 //if neither is in the table -> OK
2543                 //if tag is in the table with another id -> FAIL
2544                 //if id is in the table with another tag -> FAIL unless strict < ?
2545             }else
2546                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2547         }
2548
2549         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2550             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2551           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2552     }
2553
2554     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2555         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2556         if (!s->priv_data)
2557             return AVERROR(ENOMEM);
2558     }
2559
2560 #if LIBAVFORMAT_VERSION_MAJOR < 53
2561     ff_metadata_mux_compat(s);
2562 #endif
2563
2564     if(s->oformat->write_header){
2565         ret = s->oformat->write_header(s);
2566         if (ret < 0)
2567             return ret;
2568     }
2569
2570     /* init PTS generation */
2571     for(i=0;i<s->nb_streams;i++) {
2572         int64_t den = AV_NOPTS_VALUE;
2573         st = s->streams[i];
2574
2575         switch (st->codec->codec_type) {
2576         case CODEC_TYPE_AUDIO:
2577             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2578             break;
2579         case CODEC_TYPE_VIDEO:
2580             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2581             break;
2582         default:
2583             break;
2584         }
2585         if (den != AV_NOPTS_VALUE) {
2586             if (den <= 0)
2587                 return AVERROR_INVALIDDATA;
2588             av_frac_init(&st->pts, 0, 0, den);
2589         }
2590     }
2591     return 0;
2592 }
2593
2594 //FIXME merge with compute_pkt_fields
2595 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2596     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2597     int num, den, frame_size, i;
2598
2599 //    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);
2600
2601 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2602         return -1;*/
2603
2604     /* duration field */
2605     if (pkt->duration == 0) {
2606         compute_frame_duration(&num, &den, st, NULL, pkt);
2607         if (den && num) {
2608             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2609         }
2610     }
2611
2612     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2613         pkt->pts= pkt->dts;
2614
2615     //XXX/FIXME this is a temporary hack until all encoders output pts
2616     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2617         pkt->dts=
2618 //        pkt->pts= st->cur_dts;
2619         pkt->pts= st->pts.val;
2620     }
2621
2622     //calculate dts from pts
2623     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2624         st->pts_buffer[0]= pkt->pts;
2625         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2626             st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2627         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2628             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2629
2630         pkt->dts= st->pts_buffer[0];
2631     }
2632
2633     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2634         av_log(s, AV_LOG_ERROR,
2635                "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2636                st->index, st->cur_dts, pkt->dts);
2637         return -1;
2638     }
2639     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2640         av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2641         return -1;
2642     }
2643
2644 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2645     st->cur_dts= pkt->dts;
2646     st->pts.val= pkt->dts;
2647
2648     /* update pts */
2649     switch (st->codec->codec_type) {
2650     case CODEC_TYPE_AUDIO:
2651         frame_size = get_audio_frame_size(st->codec, pkt->size);
2652
2653         /* HACK/FIXME, we skip the initial 0 size packets as they are most
2654            likely equal to the encoder delay, but it would be better if we
2655            had the real timestamps from the encoder */
2656         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2657             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2658         }
2659         break;
2660     case CODEC_TYPE_VIDEO:
2661         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2662         break;
2663     default:
2664         break;
2665     }
2666     return 0;
2667 }
2668
2669 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2670 {
2671     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2672
2673     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2674         return ret;
2675
2676     ret= s->oformat->write_packet(s, pkt);
2677     if(!ret)
2678         ret= url_ferror(s->pb);
2679     return ret;
2680 }
2681
2682 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2683                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2684 {
2685     AVPacketList **next_point, *this_pktl;
2686
2687     this_pktl = av_mallocz(sizeof(AVPacketList));
2688     this_pktl->pkt= *pkt;
2689     pkt->destruct= NULL;             // do not free original but only the copy
2690     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2691
2692     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2693         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2694     }else
2695         next_point = &s->packet_buffer;
2696
2697     if(*next_point){
2698         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2699             while(!compare(s, &(*next_point)->pkt, pkt)){
2700                 next_point= &(*next_point)->next;
2701             }
2702             goto next_non_null;
2703         }else{
2704             next_point = &(s->packet_buffer_end->next);
2705         }
2706     }
2707     assert(!*next_point);
2708
2709     s->packet_buffer_end= this_pktl;
2710 next_non_null:
2711
2712     this_pktl->next= *next_point;
2713
2714     s->streams[pkt->stream_index]->last_in_packet_buffer=
2715     *next_point= this_pktl;
2716 }
2717
2718 int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2719 {
2720     AVStream *st = s->streams[ pkt ->stream_index];
2721     AVStream *st2= s->streams[ next->stream_index];
2722     int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
2723     int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2724
2725     if (pkt->dts == AV_NOPTS_VALUE)
2726         return 0;
2727
2728     return next->dts * left > pkt->dts * right; //FIXME this can overflow
2729 }
2730
2731 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2732     AVPacketList *pktl;
2733     int stream_count=0;
2734     int i;
2735
2736     if(pkt){
2737         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2738     }
2739
2740     for(i=0; i < s->nb_streams; i++)
2741         stream_count+= !!s->streams[i]->last_in_packet_buffer;
2742
2743     if(stream_count && (s->nb_streams == stream_count || flush)){
2744         pktl= s->packet_buffer;
2745         *out= pktl->pkt;
2746
2747         s->packet_buffer= pktl->next;
2748         if(!s->packet_buffer)
2749             s->packet_buffer_end= NULL;
2750
2751         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2752             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2753         av_freep(&pktl);
2754         return 1;
2755     }else{
2756         av_init_packet(out);
2757         return 0;
2758     }
2759 }
2760
2761 /**
2762  * Interleaves an AVPacket correctly so it can be muxed.
2763  * @param out the interleaved packet will be output here
2764  * @param in the input packet
2765  * @param flush 1 if no further packets are available as input and all
2766  *              remaining packets should be output
2767  * @return 1 if a packet was output, 0 if no packet could be output,
2768  *         < 0 if an error occurred
2769  */
2770 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2771     if(s->oformat->interleave_packet)
2772         return s->oformat->interleave_packet(s, out, in, flush);
2773     else
2774         return av_interleave_packet_per_dts(s, out, in, flush);
2775 }
2776
2777 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2778     AVStream *st= s->streams[ pkt->stream_index];
2779
2780     //FIXME/XXX/HACK drop zero sized packets
2781     if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2782         return 0;
2783
2784 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2785     if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2786         return -1;
2787
2788     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2789         return -1;
2790
2791     for(;;){
2792         AVPacket opkt;
2793         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2794         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2795             return ret;
2796
2797         ret= s->oformat->write_packet(s, &opkt);
2798
2799         av_free_packet(&opkt);
2800         pkt= NULL;
2801
2802         if(ret<0)
2803             return ret;
2804         if(url_ferror(s->pb))
2805             return url_ferror(s->pb);
2806     }
2807 }
2808
2809 int av_write_trailer(AVFormatContext *s)
2810 {
2811     int ret, i;
2812
2813     for(;;){
2814         AVPacket pkt;
2815         ret= av_interleave_packet(s, &pkt, NULL, 1);
2816         if(ret<0) //FIXME cleanup needed for ret<0 ?
2817             goto fail;
2818         if(!ret)
2819             break;
2820
2821         ret= s->oformat->write_packet(s, &pkt);
2822
2823         av_free_packet(&pkt);
2824
2825         if(ret<0)
2826             goto fail;
2827         if(url_ferror(s->pb))
2828             goto fail;
2829     }
2830
2831     if(s->oformat->write_trailer)
2832         ret = s->oformat->write_trailer(s);
2833 fail:
2834     if(ret == 0)
2835        ret=url_ferror(s->pb);
2836     for(i=0;i<s->nb_streams;i++)
2837         av_freep(&s->streams[i]->priv_data);
2838     av_freep(&s->priv_data);
2839     return ret;
2840 }
2841
2842 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2843 {
2844     int i, j;
2845     AVProgram *program=NULL;
2846     void *tmp;
2847
2848     if (idx >= ac->nb_streams) {
2849         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2850         return;
2851     }
2852
2853     for(i=0; i<ac->nb_programs; i++){
2854         if(ac->programs[i]->id != progid)
2855             continue;
2856         program = ac->programs[i];
2857         for(j=0; j<program->nb_stream_indexes; j++)
2858             if(program->stream_index[j] == idx)
2859                 return;
2860
2861         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2862         if(!tmp)
2863             return;
2864         program->stream_index = tmp;
2865         program->stream_index[program->nb_stream_indexes++] = idx;
2866         return;
2867     }
2868 }
2869
2870 static void print_fps(double d, const char *postfix){
2871     uint64_t v= lrintf(d*100);
2872     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2873     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2874     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2875 }
2876
2877 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
2878 {
2879     if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
2880         AVMetadataTag *tag=NULL;
2881
2882         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2883         while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
2884             if(strcmp("language", tag->key))
2885                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
2886         }
2887     }
2888 }
2889
2890 /* "user interface" functions */
2891 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2892 {
2893     char buf[256];
2894     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2895     AVStream *st = ic->streams[i];
2896     int g = av_gcd(st->time_base.num, st->time_base.den);
2897     AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
2898     avcodec_string(buf, sizeof(buf), st->codec, is_output);
2899     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2900     /* the pid is an important information, so we display it */
2901     /* XXX: add a generic system */
2902     if (flags & AVFMT_SHOW_IDS)
2903         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2904     if (lang)
2905         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2906     av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2907     av_log(NULL, AV_LOG_INFO, ": %s", buf);
2908     if (st->sample_aspect_ratio.num && // default
2909         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2910         AVRational display_aspect_ratio;
2911         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2912                   st->codec->width*st->sample_aspect_ratio.num,
2913                   st->codec->height*st->sample_aspect_ratio.den,
2914                   1024*1024);
2915         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2916                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2917                  display_aspect_ratio.num, display_aspect_ratio.den);
2918     }
2919     if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2920         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
2921             print_fps(av_q2d(st->avg_frame_rate), "fps");
2922         if(st->r_frame_rate.den && st->r_frame_rate.num)
2923             print_fps(av_q2d(st->r_frame_rate), "tbr");
2924         if(st->time_base.den && st->time_base.num)
2925             print_fps(1/av_q2d(st->time_base), "tbn");
2926         if(st->codec->time_base.den && st->codec->time_base.num)
2927             print_fps(1/av_q2d(st->codec->time_base), "tbc");
2928     }
2929     av_log(NULL, AV_LOG_INFO, "\n");
2930     dump_metadata(NULL, st->metadata, "    ");
2931 }
2932
2933 void dump_format(AVFormatContext *ic,
2934                  int index,
2935                  const char *url,
2936                  int is_output)
2937 {
2938     int i;
2939     uint8_t *printed = av_mallocz(ic->nb_streams);
2940     if (ic->nb_streams && !printed)
2941         return;
2942
2943     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2944             is_output ? "Output" : "Input",
2945             index,
2946             is_output ? ic->oformat->name : ic->iformat->name,
2947             is_output ? "to" : "from", url);
2948     dump_metadata(NULL, ic->metadata, "  ");
2949     if (!is_output) {
2950         av_log(NULL, AV_LOG_INFO, "  Duration: ");
2951         if (ic->duration != AV_NOPTS_VALUE) {
2952             int hours, mins, secs, us;
2953             secs = ic->duration / AV_TIME_BASE;
2954             us = ic->duration % AV_TIME_BASE;
2955             mins = secs / 60;
2956             secs %= 60;
2957             hours = mins / 60;
2958             mins %= 60;
2959             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2960                    (100 * us) / AV_TIME_BASE);
2961         } else {
2962             av_log(NULL, AV_LOG_INFO, "N/A");
2963         }
2964         if (ic->start_time != AV_NOPTS_VALUE) {
2965             int secs, us;
2966             av_log(NULL, AV_LOG_INFO, ", start: ");
2967             secs = ic->start_time / AV_TIME_BASE;
2968             us = ic->start_time % AV_TIME_BASE;
2969             av_log(NULL, AV_LOG_INFO, "%d.%06d",
2970                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2971         }
2972         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2973         if (ic->bit_rate) {
2974             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2975         } else {
2976             av_log(NULL, AV_LOG_INFO, "N/A");
2977         }
2978         av_log(NULL, AV_LOG_INFO, "\n");
2979     }
2980     if(ic->nb_programs) {
2981         int j, k, total = 0;
2982         for(j=0; j<ic->nb_programs; j++) {
2983             AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
2984                                                   "name", NULL, 0);
2985             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2986                    name ? name->value : "");
2987             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
2988             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
2989                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2990                 printed[ic->programs[j]->stream_index[k]] = 1;
2991             }
2992             total += ic->programs[j]->nb_stream_indexes;
2993         }
2994         if (total < ic->nb_streams)
2995             av_log(NULL, AV_LOG_INFO, "  No Program\n");
2996     }
2997     for(i=0;i<ic->nb_streams;i++)
2998         if (!printed[i])
2999             dump_stream_format(ic, i, index, is_output);
3000
3001     av_free(printed);
3002 }
3003
3004 #if LIBAVFORMAT_VERSION_MAJOR < 53
3005 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3006 {
3007     return av_parse_video_frame_size(width_ptr, height_ptr, str);
3008 }
3009
3010 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3011 {
3012     AVRational frame_rate;
3013     int ret = av_parse_video_frame_rate(&frame_rate, arg);
3014     *frame_rate_num= frame_rate.num;
3015     *frame_rate_den= frame_rate.den;
3016     return ret;
3017 }
3018 #endif
3019
3020 int64_t av_gettime(void)
3021 {
3022     struct timeval tv;
3023     gettimeofday(&tv,NULL);
3024     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3025 }
3026
3027 int64_t parse_date(const char *datestr, int duration)
3028 {
3029     const char *p;
3030     int64_t t;
3031     struct tm dt;
3032     int i;
3033     static const char * const date_fmt[] = {
3034         "%Y-%m-%d",
3035         "%Y%m%d",
3036     };
3037     static const char * const time_fmt[] = {
3038         "%H:%M:%S",
3039         "%H%M%S",
3040     };
3041     const char *q;
3042     int is_utc, len;
3043     char lastch;
3044     int negative = 0;
3045
3046 #undef time
3047     time_t now = time(0);
3048
3049     len = strlen(datestr);
3050     if (len > 0)
3051         lastch = datestr[len - 1];
3052     else
3053         lastch = '\0';
3054     is_utc = (lastch == 'z' || lastch == 'Z');
3055
3056     memset(&dt, 0, sizeof(dt));
3057
3058     p = datestr;
3059     q = NULL;
3060     if (!duration) {
3061         if (!strncasecmp(datestr, "now", len))
3062             return (int64_t) now * 1000000;
3063
3064         /* parse the year-month-day part */
3065         for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3066             q = small_strptime(p, date_fmt[i], &dt);
3067             if (q) {
3068                 break;
3069             }
3070         }
3071
3072         /* if the year-month-day part is missing, then take the
3073          * current year-month-day time */
3074         if (!q) {
3075             if (is_utc) {
3076                 dt = *gmtime(&now);
3077             } else {
3078                 dt = *localtime(&now);
3079             }
3080             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3081         } else {
3082             p = q;
3083         }
3084
3085         if (*p == 'T' || *p == 't' || *p == ' ')
3086             p++;
3087
3088         /* parse the hour-minute-second part */
3089         for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3090             q = small_strptime(p, time_fmt[i], &dt);
3091             if (q) {
3092                 break;
3093             }
3094         }
3095     } else {
3096         /* parse datestr as a duration */
3097         if (p[0] == '-') {
3098             negative = 1;
3099             ++p;
3100         }
3101         /* parse datestr as HH:MM:SS */
3102         q = small_strptime(p, time_fmt[0], &dt);
3103         if (!q) {
3104             /* parse datestr as S+ */
3105             dt.tm_sec = strtol(p, (char **)&q, 10);
3106             if (q == p)
3107                 /* the parsing didn't succeed */
3108                 return INT64_MIN;
3109             dt.tm_min = 0;
3110             dt.tm_hour = 0;
3111         }
3112     }
3113
3114     /* Now we have all the fields that we can get */
3115     if (!q) {
3116         return INT64_MIN;
3117     }
3118
3119     if (duration) {
3120         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3121     } else {
3122         dt.tm_isdst = -1;       /* unknown */
3123         if (is_utc) {
3124             t = mktimegm(&dt);
3125         } else {
3126             t = mktime(&dt);
3127         }
3128     }
3129
3130     t *= 1000000;
3131
3132     /* parse the .m... part */
3133     if (*q == '.') {
3134         int val, n;
3135         q++;
3136         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3137             if (!isdigit(*q))
3138                 break;
3139             val += n * (*q - '0');
3140         }
3141         t += val;
3142     }
3143     return negative ? -t : t;
3144 }
3145
3146 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3147 {
3148     const char *p;
3149     char tag[128], *q;
3150
3151     p = info;
3152     if (*p == '?')
3153         p++;
3154     for(;;) {
3155         q = tag;
3156         while (*p != '\0' && *p != '=' && *p != '&') {
3157             if ((q - tag) < sizeof(tag) - 1)
3158                 *q++ = *p;
3159             p++;
3160         }
3161         *q = '\0';
3162         q = arg;
3163         if (*p == '=') {
3164             p++;
3165             while (*p != '&' && *p != '\0') {
3166                 if ((q - arg) < arg_size - 1) {
3167                     if (*p == '+')
3168                         *q++ = ' ';
3169                     else
3170                         *q++ = *p;
3171                 }
3172                 p++;
3173             }
3174             *q = '\0';
3175         }
3176         if (!strcmp(tag, tag1))
3177             return 1;
3178         if (*p != '&')
3179             break;
3180         p++;
3181     }
3182     return 0;
3183 }
3184
3185 int av_get_frame_filename(char *buf, int buf_size,
3186                           const char *path, int number)
3187 {
3188     const char *p;
3189     char *q, buf1[20], c;
3190     int nd, len, percentd_found;
3191
3192     q = buf;
3193     p = path;
3194     percentd_found = 0;
3195     for(;;) {
3196         c = *p++;
3197         if (c == '\0')
3198             break;
3199         if (c == '%') {
3200             do {
3201                 nd = 0;
3202                 while (isdigit(*p)) {
3203                     nd = nd * 10 + *p++ - '0';
3204                 }
3205                 c = *p++;
3206             } while (isdigit(c));
3207
3208             switch(c) {
3209             case '%':
3210                 goto addchar;
3211             case 'd':
3212                 if (percentd_found)
3213                     goto fail;
3214                 percentd_found = 1;
3215                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3216                 len = strlen(buf1);
3217                 if ((q - buf + len) > buf_size - 1)
3218                     goto fail;
3219                 memcpy(q, buf1, len);
3220                 q += len;
3221                 break;
3222             default:
3223                 goto fail;
3224             }
3225         } else {
3226         addchar:
3227             if ((q - buf) < buf_size - 1)
3228                 *q++ = c;
3229         }
3230     }
3231     if (!percentd_found)
3232         goto fail;
3233     *q = '\0';
3234     return 0;
3235  fail:
3236     *q = '\0';
3237     return -1;
3238 }
3239
3240 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3241 {
3242     int len, i, j, c;
3243 #undef fprintf
3244 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3245
3246     for(i=0;i<size;i+=16) {
3247         len = size - i;
3248         if (len > 16)
3249             len = 16;
3250         PRINT("%08x ", i);
3251         for(j=0;j<16;j++) {
3252             if (j < len)
3253                 PRINT(" %02x", buf[i+j]);
3254             else
3255                 PRINT("   ");
3256         }
3257         PRINT(" ");
3258         for(j=0;j<len;j++) {
3259             c = buf[i+j];
3260             if (c < ' ' || c > '~')
3261                 c = '.';
3262             PRINT("%c", c);
3263         }
3264         PRINT("\n");
3265     }
3266 #undef PRINT
3267 }
3268
3269 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3270 {
3271     hex_dump_internal(NULL, f, 0, buf, size);
3272 }
3273
3274 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3275 {
3276     hex_dump_internal(avcl, NULL, level, buf, size);
3277 }
3278
3279  //FIXME needs to know the time_base
3280 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3281 {
3282 #undef fprintf
3283 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3284     PRINT("stream #%d:\n", pkt->stream_index);
3285     PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3286     PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3287     /* DTS is _always_ valid after av_read_frame() */
3288     PRINT("  dts=");
3289     if (pkt->dts == AV_NOPTS_VALUE)
3290         PRINT("N/A");
3291     else
3292         PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3293     /* PTS may not be known if B-frames are present. */
3294     PRINT("  pts=");
3295     if (pkt->pts == AV_NOPTS_VALUE)
3296         PRINT("N/A");
3297     else
3298         PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3299     PRINT("\n");
3300     PRINT("  size=%d\n", pkt->size);
3301 #undef PRINT
3302     if (dump_payload)
3303         av_hex_dump(f, pkt->data, pkt->size);
3304 }
3305
3306 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3307 {
3308     pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3309 }
3310
3311 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3312 {
3313     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3314 }
3315
3316 void url_split(char *proto, int proto_size,
3317                char *authorization, int authorization_size,
3318                char *hostname, int hostname_size,
3319                int *port_ptr,
3320                char *path, int path_size,
3321                const char *url)
3322 {
3323     const char *p, *ls, *at, *col, *brk;
3324
3325     if (port_ptr)               *port_ptr = -1;
3326     if (proto_size > 0)         proto[0] = 0;
3327     if (authorization_size > 0) authorization[0] = 0;
3328     if (hostname_size > 0)      hostname[0] = 0;
3329     if (path_size > 0)          path[0] = 0;
3330
3331     /* parse protocol */
3332     if ((p = strchr(url, ':'))) {
3333         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3334         p++; /* skip ':' */
3335         if (*p == '/') p++;
3336         if (*p == '/') p++;
3337     } else {
3338         /* no protocol means plain filename */
3339         av_strlcpy(path, url, path_size);
3340         return;
3341     }
3342
3343     /* separate path from hostname */
3344     ls = strchr(p, '/');
3345     if(!ls)
3346         ls = strchr(p, '?');
3347     if(ls)
3348         av_strlcpy(path, ls, path_size);
3349     else
3350         ls = &p[strlen(p)]; // XXX
3351
3352     /* the rest is hostname, use that to parse auth/port */
3353     if (ls != p) {
3354         /* authorization (user[:pass]@hostname) */
3355         if ((at = strchr(p, '@')) && at < ls) {
3356             av_strlcpy(authorization, p,
3357                        FFMIN(authorization_size, at + 1 - p));
3358             p = at + 1; /* skip '@' */
3359         }
3360
3361         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3362             /* [host]:port */
3363             av_strlcpy(hostname, p + 1,
3364                        FFMIN(hostname_size, brk - p));
3365             if (brk[1] == ':' && port_ptr)
3366                 *port_ptr = atoi(brk + 2);
3367         } else if ((col = strchr(p, ':')) && col < ls) {
3368             av_strlcpy(hostname, p,
3369                        FFMIN(col + 1 - p, hostname_size));
3370             if (port_ptr) *port_ptr = atoi(col + 1);
3371         } else
3372             av_strlcpy(hostname, p,
3373                        FFMIN(ls + 1 - p, hostname_size));
3374     }
3375 }
3376
3377 char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3378 {
3379     int i;
3380     static const char hex_table[16] = { '0', '1', '2', '3',
3381                                         '4', '5', '6', '7',
3382                                         '8', '9', 'A', 'B',
3383                                         'C', 'D', 'E', 'F' };
3384
3385     for(i = 0; i < s; i++) {
3386         buff[i * 2]     = hex_table[src[i] >> 4];
3387         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3388     }
3389
3390     return buff;
3391 }
3392
3393 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3394                      unsigned int pts_num, unsigned int pts_den)
3395 {
3396     s->pts_wrap_bits = pts_wrap_bits;
3397
3398     if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3399         if(s->time_base.num != pts_num)
3400             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3401     }else
3402         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3403
3404     if(!s->time_base.num || !s->time_base.den)
3405         s->time_base.num= s->time_base.den= 0;
3406 }