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