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