Prefer "*FUNC_NAME(" over "* FUNC_NAME(" for XXX_configuration() and
[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)
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     for(i=0;i<s->nb_streams;i++) {
2505         st = s->streams[i];
2506
2507         switch (st->codec->codec_type) {
2508         case CODEC_TYPE_AUDIO:
2509             if(st->codec->sample_rate<=0){
2510                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2511                 return -1;
2512             }
2513             if(!st->codec->block_align)
2514                 st->codec->block_align = st->codec->channels *
2515                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2516             break;
2517         case CODEC_TYPE_VIDEO:
2518             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2519                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2520                 return -1;
2521             }
2522             if(st->codec->width<=0 || st->codec->height<=0){
2523                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2524                 return -1;
2525             }
2526             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2527                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2528                 return -1;
2529             }
2530             break;
2531         }
2532
2533         if(s->oformat->codec_tag){
2534             if(st->codec->codec_tag){
2535                 //FIXME
2536                 //check that tag + id is in the table
2537                 //if neither is in the table -> OK
2538                 //if tag is in the table with another id -> FAIL
2539                 //if id is in the table with another tag -> FAIL unless strict < ?
2540             }else
2541                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2542         }
2543
2544         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2545             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2546           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2547     }
2548
2549     if (!s->priv_data && s->oformat->priv_data_size > 0) {
2550         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2551         if (!s->priv_data)
2552             return AVERROR(ENOMEM);
2553     }
2554
2555 #if LIBAVFORMAT_VERSION_MAJOR < 53
2556     ff_metadata_mux_compat(s);
2557 #endif
2558
2559     if(s->oformat->write_header){
2560         ret = s->oformat->write_header(s);
2561         if (ret < 0)
2562             return ret;
2563     }
2564
2565     /* init PTS generation */
2566     for(i=0;i<s->nb_streams;i++) {
2567         int64_t den = AV_NOPTS_VALUE;
2568         st = s->streams[i];
2569
2570         switch (st->codec->codec_type) {
2571         case CODEC_TYPE_AUDIO:
2572             den = (int64_t)st->time_base.num * st->codec->sample_rate;
2573             break;
2574         case CODEC_TYPE_VIDEO:
2575             den = (int64_t)st->time_base.num * st->codec->time_base.den;
2576             break;
2577         default:
2578             break;
2579         }
2580         if (den != AV_NOPTS_VALUE) {
2581             if (den <= 0)
2582                 return AVERROR_INVALIDDATA;
2583             av_frac_init(&st->pts, 0, 0, den);
2584         }
2585     }
2586     return 0;
2587 }
2588
2589 //FIXME merge with compute_pkt_fields
2590 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2591     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2592     int num, den, frame_size, i;
2593
2594 //    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);
2595
2596 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2597         return -1;*/
2598
2599     /* duration field */
2600     if (pkt->duration == 0) {
2601         compute_frame_duration(&num, &den, st, NULL, pkt);
2602         if (den && num) {
2603             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2604         }
2605     }
2606
2607     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2608         pkt->pts= pkt->dts;
2609
2610     //XXX/FIXME this is a temporary hack until all encoders output pts
2611     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2612         pkt->dts=
2613 //        pkt->pts= st->cur_dts;
2614         pkt->pts= st->pts.val;
2615     }
2616
2617     //calculate dts from pts
2618     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2619         st->pts_buffer[0]= pkt->pts;
2620         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2621             st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2622         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2623             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2624
2625         pkt->dts= st->pts_buffer[0];
2626     }
2627
2628     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2629         av_log(s, AV_LOG_ERROR,
2630                "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2631                st->index, st->cur_dts, pkt->dts);
2632         return -1;
2633     }
2634     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2635         av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2636         return -1;
2637     }
2638
2639 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2640     st->cur_dts= pkt->dts;
2641     st->pts.val= pkt->dts;
2642
2643     /* update pts */
2644     switch (st->codec->codec_type) {
2645     case CODEC_TYPE_AUDIO:
2646         frame_size = get_audio_frame_size(st->codec, pkt->size);
2647
2648         /* HACK/FIXME, we skip the initial 0 size packets as they are most
2649            likely equal to the encoder delay, but it would be better if we
2650            had the real timestamps from the encoder */
2651         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2652             av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2653         }
2654         break;
2655     case CODEC_TYPE_VIDEO:
2656         av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2657         break;
2658     default:
2659         break;
2660     }
2661     return 0;
2662 }
2663
2664 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2665 {
2666     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2667
2668     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2669         return ret;
2670
2671     ret= s->oformat->write_packet(s, pkt);
2672     if(!ret)
2673         ret= url_ferror(s->pb);
2674     return ret;
2675 }
2676
2677 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2678                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2679 {
2680     AVPacketList **next_point, *this_pktl;
2681
2682     this_pktl = av_mallocz(sizeof(AVPacketList));
2683     this_pktl->pkt= *pkt;
2684     pkt->destruct= NULL;             // do not free original but only the copy
2685     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
2686
2687     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2688         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2689     }else
2690         next_point = &s->packet_buffer;
2691
2692     if(*next_point){
2693         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2694             while(!compare(s, &(*next_point)->pkt, pkt)){
2695                 next_point= &(*next_point)->next;
2696             }
2697             goto next_non_null;
2698         }else{
2699             next_point = &(s->packet_buffer_end->next);
2700         }
2701     }
2702     assert(!*next_point);
2703
2704     s->packet_buffer_end= this_pktl;
2705 next_non_null:
2706
2707     this_pktl->next= *next_point;
2708
2709     s->streams[pkt->stream_index]->last_in_packet_buffer=
2710     *next_point= this_pktl;
2711 }
2712
2713 int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2714 {
2715     AVStream *st = s->streams[ pkt ->stream_index];
2716     AVStream *st2= s->streams[ next->stream_index];
2717     int64_t left = st2->time_base.num * (int64_t)st ->time_base.den;
2718     int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2719
2720     if (pkt->dts == AV_NOPTS_VALUE)
2721         return 0;
2722
2723     return next->dts * left > pkt->dts * right; //FIXME this can overflow
2724 }
2725
2726 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2727     AVPacketList *pktl;
2728     int stream_count=0;
2729     int i;
2730
2731     if(pkt){
2732         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2733     }
2734
2735     for(i=0; i < s->nb_streams; i++)
2736         stream_count+= !!s->streams[i]->last_in_packet_buffer;
2737
2738     if(stream_count && (s->nb_streams == stream_count || flush)){
2739         pktl= s->packet_buffer;
2740         *out= pktl->pkt;
2741
2742         s->packet_buffer= pktl->next;
2743         if(!s->packet_buffer)
2744             s->packet_buffer_end= NULL;
2745
2746         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2747             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2748         av_freep(&pktl);
2749         return 1;
2750     }else{
2751         av_init_packet(out);
2752         return 0;
2753     }
2754 }
2755
2756 /**
2757  * Interleaves an AVPacket correctly so it can be muxed.
2758  * @param out the interleaved packet will be output here
2759  * @param in the input packet
2760  * @param flush 1 if no further packets are available as input and all
2761  *              remaining packets should be output
2762  * @return 1 if a packet was output, 0 if no packet could be output,
2763  *         < 0 if an error occurred
2764  */
2765 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2766     if(s->oformat->interleave_packet)
2767         return s->oformat->interleave_packet(s, out, in, flush);
2768     else
2769         return av_interleave_packet_per_dts(s, out, in, flush);
2770 }
2771
2772 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2773     AVStream *st= s->streams[ pkt->stream_index];
2774
2775     //FIXME/XXX/HACK drop zero sized packets
2776     if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2777         return 0;
2778
2779 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2780     if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2781         return -1;
2782
2783     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2784         return -1;
2785
2786     for(;;){
2787         AVPacket opkt;
2788         int ret= av_interleave_packet(s, &opkt, pkt, 0);
2789         if(ret<=0) //FIXME cleanup needed for ret<0 ?
2790             return ret;
2791
2792         ret= s->oformat->write_packet(s, &opkt);
2793
2794         av_free_packet(&opkt);
2795         pkt= NULL;
2796
2797         if(ret<0)
2798             return ret;
2799         if(url_ferror(s->pb))
2800             return url_ferror(s->pb);
2801     }
2802 }
2803
2804 int av_write_trailer(AVFormatContext *s)
2805 {
2806     int ret, i;
2807
2808     for(;;){
2809         AVPacket pkt;
2810         ret= av_interleave_packet(s, &pkt, NULL, 1);
2811         if(ret<0) //FIXME cleanup needed for ret<0 ?
2812             goto fail;
2813         if(!ret)
2814             break;
2815
2816         ret= s->oformat->write_packet(s, &pkt);
2817
2818         av_free_packet(&pkt);
2819
2820         if(ret<0)
2821             goto fail;
2822         if(url_ferror(s->pb))
2823             goto fail;
2824     }
2825
2826     if(s->oformat->write_trailer)
2827         ret = s->oformat->write_trailer(s);
2828 fail:
2829     if(ret == 0)
2830        ret=url_ferror(s->pb);
2831     for(i=0;i<s->nb_streams;i++)
2832         av_freep(&s->streams[i]->priv_data);
2833     av_freep(&s->priv_data);
2834     return ret;
2835 }
2836
2837 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2838 {
2839     int i, j;
2840     AVProgram *program=NULL;
2841     void *tmp;
2842
2843     if (idx >= ac->nb_streams) {
2844         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2845         return;
2846     }
2847
2848     for(i=0; i<ac->nb_programs; i++){
2849         if(ac->programs[i]->id != progid)
2850             continue;
2851         program = ac->programs[i];
2852         for(j=0; j<program->nb_stream_indexes; j++)
2853             if(program->stream_index[j] == idx)
2854                 return;
2855
2856         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2857         if(!tmp)
2858             return;
2859         program->stream_index = tmp;
2860         program->stream_index[program->nb_stream_indexes++] = idx;
2861         return;
2862     }
2863 }
2864
2865 static void print_fps(double d, const char *postfix){
2866     uint64_t v= lrintf(d*100);
2867     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2868     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2869     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2870 }
2871
2872 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
2873 {
2874     if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
2875         AVMetadataTag *tag=NULL;
2876
2877         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2878         while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
2879             if(strcmp("language", tag->key))
2880                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
2881         }
2882     }
2883 }
2884
2885 /* "user interface" functions */
2886 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2887 {
2888     char buf[256];
2889     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2890     AVStream *st = ic->streams[i];
2891     int g = av_gcd(st->time_base.num, st->time_base.den);
2892     AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
2893     avcodec_string(buf, sizeof(buf), st->codec, is_output);
2894     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
2895     /* the pid is an important information, so we display it */
2896     /* XXX: add a generic system */
2897     if (flags & AVFMT_SHOW_IDS)
2898         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2899     if (lang)
2900         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2901     av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2902     av_log(NULL, AV_LOG_INFO, ": %s", buf);
2903     if (st->sample_aspect_ratio.num && // default
2904         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2905         AVRational display_aspect_ratio;
2906         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
2907                   st->codec->width*st->sample_aspect_ratio.num,
2908                   st->codec->height*st->sample_aspect_ratio.den,
2909                   1024*1024);
2910         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
2911                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
2912                  display_aspect_ratio.num, display_aspect_ratio.den);
2913     }
2914     if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2915         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
2916             print_fps(av_q2d(st->avg_frame_rate), "fps");
2917         if(st->r_frame_rate.den && st->r_frame_rate.num)
2918             print_fps(av_q2d(st->r_frame_rate), "tbr");
2919         if(st->time_base.den && st->time_base.num)
2920             print_fps(1/av_q2d(st->time_base), "tbn");
2921         if(st->codec->time_base.den && st->codec->time_base.num)
2922             print_fps(1/av_q2d(st->codec->time_base), "tbc");
2923     }
2924     av_log(NULL, AV_LOG_INFO, "\n");
2925     dump_metadata(NULL, st->metadata, "    ");
2926 }
2927
2928 void dump_format(AVFormatContext *ic,
2929                  int index,
2930                  const char *url,
2931                  int is_output)
2932 {
2933     int i;
2934     uint8_t *printed = av_mallocz(ic->nb_streams);
2935     if (ic->nb_streams && !printed)
2936         return;
2937
2938     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2939             is_output ? "Output" : "Input",
2940             index,
2941             is_output ? ic->oformat->name : ic->iformat->name,
2942             is_output ? "to" : "from", url);
2943     dump_metadata(NULL, ic->metadata, "  ");
2944     if (!is_output) {
2945         av_log(NULL, AV_LOG_INFO, "  Duration: ");
2946         if (ic->duration != AV_NOPTS_VALUE) {
2947             int hours, mins, secs, us;
2948             secs = ic->duration / AV_TIME_BASE;
2949             us = ic->duration % AV_TIME_BASE;
2950             mins = secs / 60;
2951             secs %= 60;
2952             hours = mins / 60;
2953             mins %= 60;
2954             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
2955                    (100 * us) / AV_TIME_BASE);
2956         } else {
2957             av_log(NULL, AV_LOG_INFO, "N/A");
2958         }
2959         if (ic->start_time != AV_NOPTS_VALUE) {
2960             int secs, us;
2961             av_log(NULL, AV_LOG_INFO, ", start: ");
2962             secs = ic->start_time / AV_TIME_BASE;
2963             us = ic->start_time % AV_TIME_BASE;
2964             av_log(NULL, AV_LOG_INFO, "%d.%06d",
2965                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2966         }
2967         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2968         if (ic->bit_rate) {
2969             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2970         } else {
2971             av_log(NULL, AV_LOG_INFO, "N/A");
2972         }
2973         av_log(NULL, AV_LOG_INFO, "\n");
2974     }
2975     if(ic->nb_programs) {
2976         int j, k, total = 0;
2977         for(j=0; j<ic->nb_programs; j++) {
2978             AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
2979                                                   "name", NULL, 0);
2980             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
2981                    name ? name->value : "");
2982             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
2983             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
2984                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
2985                 printed[ic->programs[j]->stream_index[k]] = 1;
2986             }
2987             total += ic->programs[j]->nb_stream_indexes;
2988         }
2989         if (total < ic->nb_streams)
2990             av_log(NULL, AV_LOG_INFO, "  No Program\n");
2991     }
2992     for(i=0;i<ic->nb_streams;i++)
2993         if (!printed[i])
2994             dump_stream_format(ic, i, index, is_output);
2995
2996     av_free(printed);
2997 }
2998
2999 #if LIBAVFORMAT_VERSION_MAJOR < 53
3000 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3001 {
3002     return av_parse_video_frame_size(width_ptr, height_ptr, str);
3003 }
3004
3005 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3006 {
3007     AVRational frame_rate;
3008     int ret = av_parse_video_frame_rate(&frame_rate, arg);
3009     *frame_rate_num= frame_rate.num;
3010     *frame_rate_den= frame_rate.den;
3011     return ret;
3012 }
3013 #endif
3014
3015 int64_t av_gettime(void)
3016 {
3017     struct timeval tv;
3018     gettimeofday(&tv,NULL);
3019     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3020 }
3021
3022 int64_t parse_date(const char *datestr, int duration)
3023 {
3024     const char *p;
3025     int64_t t;
3026     struct tm dt;
3027     int i;
3028     static const char * const date_fmt[] = {
3029         "%Y-%m-%d",
3030         "%Y%m%d",
3031     };
3032     static const char * const time_fmt[] = {
3033         "%H:%M:%S",
3034         "%H%M%S",
3035     };
3036     const char *q;
3037     int is_utc, len;
3038     char lastch;
3039     int negative = 0;
3040
3041 #undef time
3042     time_t now = time(0);
3043
3044     len = strlen(datestr);
3045     if (len > 0)
3046         lastch = datestr[len - 1];
3047     else
3048         lastch = '\0';
3049     is_utc = (lastch == 'z' || lastch == 'Z');
3050
3051     memset(&dt, 0, sizeof(dt));
3052
3053     p = datestr;
3054     q = NULL;
3055     if (!duration) {
3056         if (!strncasecmp(datestr, "now", len))
3057             return (int64_t) now * 1000000;
3058
3059         /* parse the year-month-day part */
3060         for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3061             q = small_strptime(p, date_fmt[i], &dt);
3062             if (q) {
3063                 break;
3064             }
3065         }
3066
3067         /* if the year-month-day part is missing, then take the
3068          * current year-month-day time */
3069         if (!q) {
3070             if (is_utc) {
3071                 dt = *gmtime(&now);
3072             } else {
3073                 dt = *localtime(&now);
3074             }
3075             dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3076         } else {
3077             p = q;
3078         }
3079
3080         if (*p == 'T' || *p == 't' || *p == ' ')
3081             p++;
3082
3083         /* parse the hour-minute-second part */
3084         for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3085             q = small_strptime(p, time_fmt[i], &dt);
3086             if (q) {
3087                 break;
3088             }
3089         }
3090     } else {
3091         /* parse datestr as a duration */
3092         if (p[0] == '-') {
3093             negative = 1;
3094             ++p;
3095         }
3096         /* parse datestr as HH:MM:SS */
3097         q = small_strptime(p, time_fmt[0], &dt);
3098         if (!q) {
3099             /* parse datestr as S+ */
3100             dt.tm_sec = strtol(p, (char **)&q, 10);
3101             if (q == p)
3102                 /* the parsing didn't succeed */
3103                 return INT64_MIN;
3104             dt.tm_min = 0;
3105             dt.tm_hour = 0;
3106         }
3107     }
3108
3109     /* Now we have all the fields that we can get */
3110     if (!q) {
3111         return INT64_MIN;
3112     }
3113
3114     if (duration) {
3115         t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3116     } else {
3117         dt.tm_isdst = -1;       /* unknown */
3118         if (is_utc) {
3119             t = mktimegm(&dt);
3120         } else {
3121             t = mktime(&dt);
3122         }
3123     }
3124
3125     t *= 1000000;
3126
3127     /* parse the .m... part */
3128     if (*q == '.') {
3129         int val, n;
3130         q++;
3131         for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3132             if (!isdigit(*q))
3133                 break;
3134             val += n * (*q - '0');
3135         }
3136         t += val;
3137     }
3138     return negative ? -t : t;
3139 }
3140
3141 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3142 {
3143     const char *p;
3144     char tag[128], *q;
3145
3146     p = info;
3147     if (*p == '?')
3148         p++;
3149     for(;;) {
3150         q = tag;
3151         while (*p != '\0' && *p != '=' && *p != '&') {
3152             if ((q - tag) < sizeof(tag) - 1)
3153                 *q++ = *p;
3154             p++;
3155         }
3156         *q = '\0';
3157         q = arg;
3158         if (*p == '=') {
3159             p++;
3160             while (*p != '&' && *p != '\0') {
3161                 if ((q - arg) < arg_size - 1) {
3162                     if (*p == '+')
3163                         *q++ = ' ';
3164                     else
3165                         *q++ = *p;
3166                 }
3167                 p++;
3168             }
3169             *q = '\0';
3170         }
3171         if (!strcmp(tag, tag1))
3172             return 1;
3173         if (*p != '&')
3174             break;
3175         p++;
3176     }
3177     return 0;
3178 }
3179
3180 int av_get_frame_filename(char *buf, int buf_size,
3181                           const char *path, int number)
3182 {
3183     const char *p;
3184     char *q, buf1[20], c;
3185     int nd, len, percentd_found;
3186
3187     q = buf;
3188     p = path;
3189     percentd_found = 0;
3190     for(;;) {
3191         c = *p++;
3192         if (c == '\0')
3193             break;
3194         if (c == '%') {
3195             do {
3196                 nd = 0;
3197                 while (isdigit(*p)) {
3198                     nd = nd * 10 + *p++ - '0';
3199                 }
3200                 c = *p++;
3201             } while (isdigit(c));
3202
3203             switch(c) {
3204             case '%':
3205                 goto addchar;
3206             case 'd':
3207                 if (percentd_found)
3208                     goto fail;
3209                 percentd_found = 1;
3210                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3211                 len = strlen(buf1);
3212                 if ((q - buf + len) > buf_size - 1)
3213                     goto fail;
3214                 memcpy(q, buf1, len);
3215                 q += len;
3216                 break;
3217             default:
3218                 goto fail;
3219             }
3220         } else {
3221         addchar:
3222             if ((q - buf) < buf_size - 1)
3223                 *q++ = c;
3224         }
3225     }
3226     if (!percentd_found)
3227         goto fail;
3228     *q = '\0';
3229     return 0;
3230  fail:
3231     *q = '\0';
3232     return -1;
3233 }
3234
3235 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3236 {
3237     int len, i, j, c;
3238 #undef fprintf
3239 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3240
3241     for(i=0;i<size;i+=16) {
3242         len = size - i;
3243         if (len > 16)
3244             len = 16;
3245         PRINT("%08x ", i);
3246         for(j=0;j<16;j++) {
3247             if (j < len)
3248                 PRINT(" %02x", buf[i+j]);
3249             else
3250                 PRINT("   ");
3251         }
3252         PRINT(" ");
3253         for(j=0;j<len;j++) {
3254             c = buf[i+j];
3255             if (c < ' ' || c > '~')
3256                 c = '.';
3257             PRINT("%c", c);
3258         }
3259         PRINT("\n");
3260     }
3261 #undef PRINT
3262 }
3263
3264 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3265 {
3266     hex_dump_internal(NULL, f, 0, buf, size);
3267 }
3268
3269 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3270 {
3271     hex_dump_internal(avcl, NULL, level, buf, size);
3272 }
3273
3274  //FIXME needs to know the time_base
3275 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3276 {
3277 #undef fprintf
3278 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3279     PRINT("stream #%d:\n", pkt->stream_index);
3280     PRINT("  keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
3281     PRINT("  duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3282     /* DTS is _always_ valid after av_read_frame() */
3283     PRINT("  dts=");
3284     if (pkt->dts == AV_NOPTS_VALUE)
3285         PRINT("N/A");
3286     else
3287         PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3288     /* PTS may not be known if B-frames are present. */
3289     PRINT("  pts=");
3290     if (pkt->pts == AV_NOPTS_VALUE)
3291         PRINT("N/A");
3292     else
3293         PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3294     PRINT("\n");
3295     PRINT("  size=%d\n", pkt->size);
3296 #undef PRINT
3297     if (dump_payload)
3298         av_hex_dump(f, pkt->data, pkt->size);
3299 }
3300
3301 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3302 {
3303     pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3304 }
3305
3306 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3307 {
3308     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3309 }
3310
3311 void url_split(char *proto, int proto_size,
3312                char *authorization, int authorization_size,
3313                char *hostname, int hostname_size,
3314                int *port_ptr,
3315                char *path, int path_size,
3316                const char *url)
3317 {
3318     const char *p, *ls, *at, *col, *brk;
3319
3320     if (port_ptr)               *port_ptr = -1;
3321     if (proto_size > 0)         proto[0] = 0;
3322     if (authorization_size > 0) authorization[0] = 0;
3323     if (hostname_size > 0)      hostname[0] = 0;
3324     if (path_size > 0)          path[0] = 0;
3325
3326     /* parse protocol */
3327     if ((p = strchr(url, ':'))) {
3328         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3329         p++; /* skip ':' */
3330         if (*p == '/') p++;
3331         if (*p == '/') p++;
3332     } else {
3333         /* no protocol means plain filename */
3334         av_strlcpy(path, url, path_size);
3335         return;
3336     }
3337
3338     /* separate path from hostname */
3339     ls = strchr(p, '/');
3340     if(!ls)
3341         ls = strchr(p, '?');
3342     if(ls)
3343         av_strlcpy(path, ls, path_size);
3344     else
3345         ls = &p[strlen(p)]; // XXX
3346
3347     /* the rest is hostname, use that to parse auth/port */
3348     if (ls != p) {
3349         /* authorization (user[:pass]@hostname) */
3350         if ((at = strchr(p, '@')) && at < ls) {
3351             av_strlcpy(authorization, p,
3352                        FFMIN(authorization_size, at + 1 - p));
3353             p = at + 1; /* skip '@' */
3354         }
3355
3356         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3357             /* [host]:port */
3358             av_strlcpy(hostname, p + 1,
3359                        FFMIN(hostname_size, brk - p));
3360             if (brk[1] == ':' && port_ptr)
3361                 *port_ptr = atoi(brk + 2);
3362         } else if ((col = strchr(p, ':')) && col < ls) {
3363             av_strlcpy(hostname, p,
3364                        FFMIN(col + 1 - p, hostname_size));
3365             if (port_ptr) *port_ptr = atoi(col + 1);
3366         } else
3367             av_strlcpy(hostname, p,
3368                        FFMIN(ls + 1 - p, hostname_size));
3369     }
3370 }
3371
3372 char *ff_data_to_hex(char *buff, const uint8_t *src, int s)
3373 {
3374     int i;
3375     static const char hex_table[16] = { '0', '1', '2', '3',
3376                                         '4', '5', '6', '7',
3377                                         '8', '9', 'A', 'B',
3378                                         'C', 'D', 'E', 'F' };
3379
3380     for(i = 0; i < s; i++) {
3381         buff[i * 2]     = hex_table[src[i] >> 4];
3382         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3383     }
3384
3385     return buff;
3386 }
3387
3388 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3389                      unsigned int pts_num, unsigned int pts_den)
3390 {
3391     s->pts_wrap_bits = pts_wrap_bits;
3392
3393     if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3394         if(s->time_base.num != pts_num)
3395             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3396     }else
3397         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3398
3399     if(!s->time_base.num || !s->time_base.den)
3400         s->time_base.num= s->time_base.den= 0;
3401 }