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