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