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