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