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