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