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