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