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