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