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