ffmpeg: add -benchmark_all option.
[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<<48))
76
77 static int is_relative(int64_t ts) {
78     return ts > (RELATIVE_TS_BASE - (1LL<<48));
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 | s->avio_flags,
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 duration:%d\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc, pkt->duration);
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     } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1137         // preserve 0-size sync packets
1138         compute_pkt_fields(s, st, st->parser, pkt);
1139     }
1140
1141     while (size > 0 || (pkt == &flush_pkt && got_output)) {
1142         int len;
1143
1144         av_init_packet(&out_pkt);
1145         len = av_parser_parse2(st->parser,  st->codec,
1146                                &out_pkt.data, &out_pkt.size, data, size,
1147                                pkt->pts, pkt->dts, pkt->pos);
1148
1149         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1150         /* increment read pointer */
1151         data += len;
1152         size -= len;
1153
1154         got_output = !!out_pkt.size;
1155
1156         if (!out_pkt.size)
1157             continue;
1158
1159         /* set the duration */
1160         out_pkt.duration = 0;
1161         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1162             if (st->codec->sample_rate > 0) {
1163                 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1164                                                     (AVRational){ 1, st->codec->sample_rate },
1165                                                     st->time_base,
1166                                                     AV_ROUND_DOWN);
1167             }
1168         } else if (st->codec->time_base.num != 0 &&
1169                    st->codec->time_base.den != 0) {
1170             out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1171                                                 st->codec->time_base,
1172                                                 st->time_base,
1173                                                 AV_ROUND_DOWN);
1174         }
1175
1176         out_pkt.stream_index = st->index;
1177         out_pkt.pts = st->parser->pts;
1178         out_pkt.dts = st->parser->dts;
1179         out_pkt.pos = st->parser->pos;
1180
1181         if (st->parser->key_frame == 1 ||
1182             (st->parser->key_frame == -1 &&
1183              st->parser->pict_type == AV_PICTURE_TYPE_I))
1184             out_pkt.flags |= AV_PKT_FLAG_KEY;
1185
1186         compute_pkt_fields(s, st, st->parser, &out_pkt);
1187
1188         if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1189             out_pkt.flags & AV_PKT_FLAG_KEY) {
1190             int64_t pos= (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? out_pkt.pos : st->parser->frame_offset;
1191             ff_reduce_index(s, st->index);
1192             av_add_index_entry(st, pos, out_pkt.dts,
1193                                0, 0, AVINDEX_KEYFRAME);
1194         }
1195
1196         if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1197             out_pkt.destruct = pkt->destruct;
1198             pkt->destruct = NULL;
1199         }
1200         if ((ret = av_dup_packet(&out_pkt)) < 0)
1201             goto fail;
1202
1203         if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1204             av_free_packet(&out_pkt);
1205             ret = AVERROR(ENOMEM);
1206             goto fail;
1207         }
1208     }
1209
1210
1211     /* end of the stream => close and free the parser */
1212     if (pkt == &flush_pkt) {
1213         av_parser_close(st->parser);
1214         st->parser = NULL;
1215     }
1216
1217 fail:
1218     av_free_packet(pkt);
1219     return ret;
1220 }
1221
1222 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1223                                    AVPacketList **pkt_buffer_end,
1224                                    AVPacket      *pkt)
1225 {
1226     AVPacketList *pktl;
1227     av_assert0(*pkt_buffer);
1228     pktl = *pkt_buffer;
1229     *pkt = pktl->pkt;
1230     *pkt_buffer = pktl->next;
1231     if (!pktl->next)
1232         *pkt_buffer_end = NULL;
1233     av_freep(&pktl);
1234     return 0;
1235 }
1236
1237 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1238 {
1239     int ret = 0, i, got_packet = 0;
1240
1241     av_init_packet(pkt);
1242
1243     while (!got_packet && !s->parse_queue) {
1244         AVStream *st;
1245         AVPacket cur_pkt;
1246
1247         /* read next packet */
1248         ret = ff_read_packet(s, &cur_pkt);
1249         if (ret < 0) {
1250             if (ret == AVERROR(EAGAIN))
1251                 return ret;
1252             /* flush the parsers */
1253             for(i = 0; i < s->nb_streams; i++) {
1254                 st = s->streams[i];
1255                 if (st->parser && st->need_parsing)
1256                     parse_packet(s, NULL, st->index);
1257             }
1258             /* all remaining packets are now in parse_queue =>
1259              * really terminate parsing */
1260             break;
1261         }
1262         ret = 0;
1263         st  = s->streams[cur_pkt.stream_index];
1264
1265         if (cur_pkt.pts != AV_NOPTS_VALUE &&
1266             cur_pkt.dts != AV_NOPTS_VALUE &&
1267             cur_pkt.pts < cur_pkt.dts) {
1268             av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1269                    cur_pkt.stream_index,
1270                    cur_pkt.pts,
1271                    cur_pkt.dts,
1272                    cur_pkt.size);
1273         }
1274         if (s->debug & FF_FDEBUG_TS)
1275             av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1276                    cur_pkt.stream_index,
1277                    cur_pkt.pts,
1278                    cur_pkt.dts,
1279                    cur_pkt.size,
1280                    cur_pkt.duration,
1281                    cur_pkt.flags);
1282
1283         if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1284             st->parser = av_parser_init(st->codec->codec_id);
1285             if (!st->parser) {
1286                 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1287                        "%s, packets or times may be invalid.\n",
1288                        avcodec_get_name(st->codec->codec_id));
1289                 /* no parser available: just output the raw packets */
1290                 st->need_parsing = AVSTREAM_PARSE_NONE;
1291             } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1292                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1293             } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1294                 st->parser->flags |= PARSER_FLAG_ONCE;
1295             }
1296         }
1297
1298         if (!st->need_parsing || !st->parser) {
1299             /* no parsing needed: we just output the packet as is */
1300             *pkt = cur_pkt;
1301             compute_pkt_fields(s, st, NULL, pkt);
1302             if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1303                 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1304                 ff_reduce_index(s, st->index);
1305                 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1306             }
1307             got_packet = 1;
1308         } else if (st->discard < AVDISCARD_ALL) {
1309             if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1310                 return ret;
1311         } else {
1312             /* free packet */
1313             av_free_packet(&cur_pkt);
1314         }
1315     }
1316
1317     if (!got_packet && s->parse_queue)
1318         ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1319
1320     if(s->debug & FF_FDEBUG_TS)
1321         av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1322             pkt->stream_index,
1323             pkt->pts,
1324             pkt->dts,
1325             pkt->size,
1326             pkt->duration,
1327             pkt->flags);
1328
1329     return ret;
1330 }
1331
1332 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1333 {
1334     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1335     int          eof = 0;
1336     int ret;
1337
1338     if (!genpts) {
1339         ret = s->packet_buffer ? read_from_packet_buffer(&s->packet_buffer,
1340                                                           &s->packet_buffer_end,
1341                                                           pkt) :
1342                                   read_frame_internal(s, pkt);
1343         goto return_packet;
1344     }
1345
1346     for (;;) {
1347         AVPacketList *pktl = s->packet_buffer;
1348
1349         if (pktl) {
1350             AVPacket *next_pkt = &pktl->pkt;
1351
1352             if (next_pkt->dts != AV_NOPTS_VALUE) {
1353                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1354                 // last dts seen for this stream. if any of packets following
1355                 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1356                 int64_t last_dts = next_pkt->dts;
1357                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1358                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1359                         (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1360                         if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1361                             next_pkt->pts = pktl->pkt.dts;
1362                         }
1363                         if (last_dts != AV_NOPTS_VALUE) {
1364                             // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1365                             last_dts = pktl->pkt.dts;
1366                         }
1367                     }
1368                     pktl = pktl->next;
1369                 }
1370                 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1371                     // Fixing the last reference frame had none pts issue (For MXF etc).
1372                     // We only do this when
1373                     // 1. eof.
1374                     // 2. we are not able to resolve a pts value for current packet.
1375                     // 3. the packets for this stream at the end of the files had valid dts.
1376                     next_pkt->pts = last_dts + next_pkt->duration;
1377                 }
1378                 pktl = s->packet_buffer;
1379             }
1380
1381             /* read packet from packet buffer, if there is data */
1382             if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1383                   next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1384                 ret = read_from_packet_buffer(&s->packet_buffer,
1385                                                &s->packet_buffer_end, pkt);
1386                 goto return_packet;
1387             }
1388         }
1389
1390         ret = read_frame_internal(s, pkt);
1391         if (ret < 0) {
1392             if (pktl && ret != AVERROR(EAGAIN)) {
1393                 eof = 1;
1394                 continue;
1395             } else
1396                 return ret;
1397         }
1398
1399         if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1400                           &s->packet_buffer_end)) < 0)
1401             return AVERROR(ENOMEM);
1402     }
1403
1404 return_packet:
1405     if (is_relative(pkt->dts))
1406         pkt->dts -= RELATIVE_TS_BASE;
1407     if (is_relative(pkt->pts))
1408         pkt->pts -= RELATIVE_TS_BASE;
1409     return ret;
1410 }
1411
1412 /* XXX: suppress the packet queue */
1413 static void flush_packet_queue(AVFormatContext *s)
1414 {
1415     free_packet_buffer(&s->parse_queue,       &s->parse_queue_end);
1416     free_packet_buffer(&s->packet_buffer,     &s->packet_buffer_end);
1417     free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1418
1419     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1420 }
1421
1422 /*******************************************************/
1423 /* seek support */
1424
1425 int av_find_default_stream_index(AVFormatContext *s)
1426 {
1427     int first_audio_index = -1;
1428     int i;
1429     AVStream *st;
1430
1431     if (s->nb_streams <= 0)
1432         return -1;
1433     for(i = 0; i < s->nb_streams; i++) {
1434         st = s->streams[i];
1435         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1436             !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1437             return i;
1438         }
1439         if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1440             first_audio_index = i;
1441     }
1442     return first_audio_index >= 0 ? first_audio_index : 0;
1443 }
1444
1445 /**
1446  * Flush the frame reader.
1447  */
1448 void ff_read_frame_flush(AVFormatContext *s)
1449 {
1450     AVStream *st;
1451     int i, j;
1452
1453     flush_packet_queue(s);
1454
1455     /* for each stream, reset read state */
1456     for(i = 0; i < s->nb_streams; i++) {
1457         st = s->streams[i];
1458
1459         if (st->parser) {
1460             av_parser_close(st->parser);
1461             st->parser = NULL;
1462         }
1463         st->last_IP_pts = AV_NOPTS_VALUE;
1464         if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = RELATIVE_TS_BASE;
1465         else                                st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1466         st->reference_dts = AV_NOPTS_VALUE;
1467
1468         st->probe_packets = MAX_PROBE_PACKETS;
1469
1470         for(j=0; j<MAX_REORDER_DELAY+1; j++)
1471             st->pts_buffer[j]= AV_NOPTS_VALUE;
1472     }
1473 }
1474
1475 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1476 {
1477     int i;
1478
1479     for(i = 0; i < s->nb_streams; i++) {
1480         AVStream *st = s->streams[i];
1481
1482         st->cur_dts = av_rescale(timestamp,
1483                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1484                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1485     }
1486 }
1487
1488 void ff_reduce_index(AVFormatContext *s, int stream_index)
1489 {
1490     AVStream *st= s->streams[stream_index];
1491     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1492
1493     if((unsigned)st->nb_index_entries >= max_entries){
1494         int i;
1495         for(i=0; 2*i<st->nb_index_entries; i++)
1496             st->index_entries[i]= st->index_entries[2*i];
1497         st->nb_index_entries= i;
1498     }
1499 }
1500
1501 int ff_add_index_entry(AVIndexEntry **index_entries,
1502                        int *nb_index_entries,
1503                        unsigned int *index_entries_allocated_size,
1504                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1505 {
1506     AVIndexEntry *entries, *ie;
1507     int index;
1508
1509     if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1510         return -1;
1511
1512     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1513         timestamp -= RELATIVE_TS_BASE;
1514
1515     entries = av_fast_realloc(*index_entries,
1516                               index_entries_allocated_size,
1517                               (*nb_index_entries + 1) *
1518                               sizeof(AVIndexEntry));
1519     if(!entries)
1520         return -1;
1521
1522     *index_entries= entries;
1523
1524     index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1525
1526     if(index<0){
1527         index= (*nb_index_entries)++;
1528         ie= &entries[index];
1529         assert(index==0 || ie[-1].timestamp < timestamp);
1530     }else{
1531         ie= &entries[index];
1532         if(ie->timestamp != timestamp){
1533             if(ie->timestamp <= timestamp)
1534                 return -1;
1535             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1536             (*nb_index_entries)++;
1537         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1538             distance= ie->min_distance;
1539     }
1540
1541     ie->pos = pos;
1542     ie->timestamp = timestamp;
1543     ie->min_distance= distance;
1544     ie->size= size;
1545     ie->flags = flags;
1546
1547     return index;
1548 }
1549
1550 int av_add_index_entry(AVStream *st,
1551                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1552 {
1553     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1554                               &st->index_entries_allocated_size, pos,
1555                               timestamp, size, distance, flags);
1556 }
1557
1558 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1559                               int64_t wanted_timestamp, int flags)
1560 {
1561     int a, b, m;
1562     int64_t timestamp;
1563
1564     a = - 1;
1565     b = nb_entries;
1566
1567     //optimize appending index entries at the end
1568     if(b && entries[b-1].timestamp < wanted_timestamp)
1569         a= b-1;
1570
1571     while (b - a > 1) {
1572         m = (a + b) >> 1;
1573         timestamp = entries[m].timestamp;
1574         if(timestamp >= wanted_timestamp)
1575             b = m;
1576         if(timestamp <= wanted_timestamp)
1577             a = m;
1578     }
1579     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1580
1581     if(!(flags & AVSEEK_FLAG_ANY)){
1582         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1583             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1584         }
1585     }
1586
1587     if(m == nb_entries)
1588         return -1;
1589     return  m;
1590 }
1591
1592 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1593                               int flags)
1594 {
1595     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1596                                      wanted_timestamp, flags);
1597 }
1598
1599 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1600 {
1601     AVInputFormat *avif= s->iformat;
1602     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1603     int64_t ts_min, ts_max, ts;
1604     int index;
1605     int64_t ret;
1606     AVStream *st;
1607
1608     if (stream_index < 0)
1609         return -1;
1610
1611     av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1612
1613     ts_max=
1614     ts_min= AV_NOPTS_VALUE;
1615     pos_limit= -1; //gcc falsely says it may be uninitialized
1616
1617     st= s->streams[stream_index];
1618     if(st->index_entries){
1619         AVIndexEntry *e;
1620
1621         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()
1622         index= FFMAX(index, 0);
1623         e= &st->index_entries[index];
1624
1625         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1626             pos_min= e->pos;
1627             ts_min= e->timestamp;
1628             av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1629                     pos_min,ts_min);
1630         }else{
1631             assert(index==0);
1632         }
1633
1634         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1635         assert(index < st->nb_index_entries);
1636         if(index >= 0){
1637             e= &st->index_entries[index];
1638             assert(e->timestamp >= target_ts);
1639             pos_max= e->pos;
1640             ts_max= e->timestamp;
1641             pos_limit= pos_max - e->min_distance;
1642             av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1643                     pos_max,pos_limit, ts_max);
1644         }
1645     }
1646
1647     pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1648     if(pos<0)
1649         return -1;
1650
1651     /* do the seek */
1652     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1653         return ret;
1654
1655     ff_read_frame_flush(s);
1656     ff_update_cur_dts(s, st, ts);
1657
1658     return 0;
1659 }
1660
1661 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1662                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1663                       int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1664                       int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1665 {
1666     int64_t pos, ts;
1667     int64_t start_pos, filesize;
1668     int no_change;
1669
1670     av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1671
1672     if(ts_min == AV_NOPTS_VALUE){
1673         pos_min = s->data_offset;
1674         ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1675         if (ts_min == AV_NOPTS_VALUE)
1676             return -1;
1677     }
1678
1679     if(ts_min >= target_ts){
1680         *ts_ret= ts_min;
1681         return pos_min;
1682     }
1683
1684     if(ts_max == AV_NOPTS_VALUE){
1685         int step= 1024;
1686         filesize = avio_size(s->pb);
1687         pos_max = filesize - 1;
1688         do{
1689             pos_max -= step;
1690             ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1691             step += step;
1692         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1693         if (ts_max == AV_NOPTS_VALUE)
1694             return -1;
1695
1696         for(;;){
1697             int64_t tmp_pos= pos_max + 1;
1698             int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1699             if(tmp_ts == AV_NOPTS_VALUE)
1700                 break;
1701             ts_max= tmp_ts;
1702             pos_max= tmp_pos;
1703             if(tmp_pos >= filesize)
1704                 break;
1705         }
1706         pos_limit= pos_max;
1707     }
1708
1709     if(ts_max <= target_ts){
1710         *ts_ret= ts_max;
1711         return pos_max;
1712     }
1713
1714     if(ts_min > ts_max){
1715         return -1;
1716     }else if(ts_min == ts_max){
1717         pos_limit= pos_min;
1718     }
1719
1720     no_change=0;
1721     while (pos_min < pos_limit) {
1722         av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1723                 pos_min, pos_max, ts_min, ts_max);
1724         assert(pos_limit <= pos_max);
1725
1726         if(no_change==0){
1727             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1728             // interpolate position (better than dichotomy)
1729             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1730                 + pos_min - approximate_keyframe_distance;
1731         }else if(no_change==1){
1732             // bisection, if interpolation failed to change min or max pos last time
1733             pos = (pos_min + pos_limit)>>1;
1734         }else{
1735             /* linear search if bisection failed, can only happen if there
1736                are very few or no keyframes between min/max */
1737             pos=pos_min;
1738         }
1739         if(pos <= pos_min)
1740             pos= pos_min + 1;
1741         else if(pos > pos_limit)
1742             pos= pos_limit;
1743         start_pos= pos;
1744
1745         ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1746         if(pos == pos_max)
1747             no_change++;
1748         else
1749             no_change=0;
1750         av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1751                 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1752                 pos_limit, start_pos, no_change);
1753         if(ts == AV_NOPTS_VALUE){
1754             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1755             return -1;
1756         }
1757         assert(ts != AV_NOPTS_VALUE);
1758         if (target_ts <= ts) {
1759             pos_limit = start_pos - 1;
1760             pos_max = pos;
1761             ts_max = ts;
1762         }
1763         if (target_ts >= ts) {
1764             pos_min = pos;
1765             ts_min = ts;
1766         }
1767     }
1768
1769     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1770     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1771 #if 0
1772     pos_min = pos;
1773     ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1774     pos_min++;
1775     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1776     av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1777             pos, ts_min, target_ts, ts_max);
1778 #endif
1779     *ts_ret= ts;
1780     return pos;
1781 }
1782
1783 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1784     int64_t pos_min, pos_max;
1785
1786     pos_min = s->data_offset;
1787     pos_max = avio_size(s->pb) - 1;
1788
1789     if     (pos < pos_min) pos= pos_min;
1790     else if(pos > pos_max) pos= pos_max;
1791
1792     avio_seek(s->pb, pos, SEEK_SET);
1793
1794     return 0;
1795 }
1796
1797 static int seek_frame_generic(AVFormatContext *s,
1798                                  int stream_index, int64_t timestamp, int flags)
1799 {
1800     int index;
1801     int64_t ret;
1802     AVStream *st;
1803     AVIndexEntry *ie;
1804
1805     st = s->streams[stream_index];
1806
1807     index = av_index_search_timestamp(st, timestamp, flags);
1808
1809     if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1810         return -1;
1811
1812     if(index < 0 || index==st->nb_index_entries-1){
1813         AVPacket pkt;
1814         int nonkey=0;
1815
1816         if(st->nb_index_entries){
1817             assert(st->index_entries);
1818             ie= &st->index_entries[st->nb_index_entries-1];
1819             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1820                 return ret;
1821             ff_update_cur_dts(s, st, ie->timestamp);
1822         }else{
1823             if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1824                 return ret;
1825         }
1826         for (;;) {
1827             int read_status;
1828             do{
1829                 read_status = av_read_frame(s, &pkt);
1830             } while (read_status == AVERROR(EAGAIN));
1831             if (read_status < 0)
1832                 break;
1833             av_free_packet(&pkt);
1834             if(stream_index == pkt.stream_index && pkt.dts > timestamp){
1835                 if(pkt.flags & AV_PKT_FLAG_KEY)
1836                     break;
1837                 if(nonkey++ > 1000 && st->codec->codec_id != CODEC_ID_CDGRAPHICS){
1838                     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);
1839                     break;
1840                 }
1841             }
1842         }
1843         index = av_index_search_timestamp(st, timestamp, flags);
1844     }
1845     if (index < 0)
1846         return -1;
1847
1848     ff_read_frame_flush(s);
1849     AV_NOWARN_DEPRECATED(
1850     if (s->iformat->read_seek){
1851         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1852             return 0;
1853     }
1854     )
1855     ie = &st->index_entries[index];
1856     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1857         return ret;
1858     ff_update_cur_dts(s, st, ie->timestamp);
1859
1860     return 0;
1861 }
1862
1863 static int seek_frame_internal(AVFormatContext *s, int stream_index,
1864                                int64_t timestamp, int flags)
1865 {
1866     int ret;
1867     AVStream *st;
1868
1869     if (flags & AVSEEK_FLAG_BYTE) {
1870         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1871             return -1;
1872         ff_read_frame_flush(s);
1873         return seek_frame_byte(s, stream_index, timestamp, flags);
1874     }
1875
1876     if(stream_index < 0){
1877         stream_index= av_find_default_stream_index(s);
1878         if(stream_index < 0)
1879             return -1;
1880
1881         st= s->streams[stream_index];
1882         /* timestamp for default must be expressed in AV_TIME_BASE units */
1883         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1884     }
1885
1886     /* first, we try the format specific seek */
1887     AV_NOWARN_DEPRECATED(
1888     if (s->iformat->read_seek) {
1889         ff_read_frame_flush(s);
1890         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1891     } else
1892         ret = -1;
1893     )
1894     if (ret >= 0) {
1895         return 0;
1896     }
1897
1898     if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1899         ff_read_frame_flush(s);
1900         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1901     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1902         ff_read_frame_flush(s);
1903         return seek_frame_generic(s, stream_index, timestamp, flags);
1904     }
1905     else
1906         return -1;
1907 }
1908
1909 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1910 {
1911     int ret = seek_frame_internal(s, stream_index, timestamp, flags);
1912
1913     if (ret >= 0)
1914         queue_attached_pictures(s);
1915
1916     return ret;
1917 }
1918
1919 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1920 {
1921     if(min_ts > ts || max_ts < ts)
1922         return -1;
1923
1924     if (s->iformat->read_seek2) {
1925         int ret;
1926         ff_read_frame_flush(s);
1927         ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1928
1929         if (ret >= 0)
1930             queue_attached_pictures(s);
1931         return ret;
1932     }
1933
1934     if(s->iformat->read_timestamp){
1935         //try to seek via read_timestamp()
1936     }
1937
1938     //Fallback to old API if new is not implemented but old is
1939     //Note the old has somewat different sematics
1940     AV_NOWARN_DEPRECATED(
1941     if (s->iformat->read_seek || 1) {
1942         int dir = (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0);
1943         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
1944         if (ret<0 && ts != min_ts && max_ts != ts) {
1945             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
1946             if (ret >= 0)
1947                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
1948         }
1949         return ret;
1950     }
1951     )
1952
1953     // try some generic seek like seek_frame_generic() but with new ts semantics
1954 }
1955
1956 /*******************************************************/
1957
1958 /**
1959  * Return TRUE if the stream has accurate duration in any stream.
1960  *
1961  * @return TRUE if the stream has accurate duration for at least one component.
1962  */
1963 static int has_duration(AVFormatContext *ic)
1964 {
1965     int i;
1966     AVStream *st;
1967     if(ic->duration != AV_NOPTS_VALUE)
1968         return 1;
1969
1970     for(i = 0;i < ic->nb_streams; i++) {
1971         st = ic->streams[i];
1972         if (st->duration != AV_NOPTS_VALUE)
1973             return 1;
1974     }
1975     return 0;
1976 }
1977
1978 /**
1979  * Estimate the stream timings from the one of each components.
1980  *
1981  * Also computes the global bitrate if possible.
1982  */
1983 static void update_stream_timings(AVFormatContext *ic)
1984 {
1985     int64_t start_time, start_time1, start_time_text, end_time, end_time1;
1986     int64_t duration, duration1, filesize;
1987     int i;
1988     AVStream *st;
1989
1990     start_time = INT64_MAX;
1991     start_time_text = INT64_MAX;
1992     end_time = INT64_MIN;
1993     duration = INT64_MIN;
1994     for(i = 0;i < ic->nb_streams; i++) {
1995         st = ic->streams[i];
1996         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1997             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1998             if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1999                 if (start_time1 < start_time_text)
2000                     start_time_text = start_time1;
2001             } else
2002             start_time = FFMIN(start_time, start_time1);
2003             if (st->duration != AV_NOPTS_VALUE) {
2004                 end_time1 = start_time1
2005                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2006                 end_time = FFMAX(end_time, end_time1);
2007             }
2008         }
2009         if (st->duration != AV_NOPTS_VALUE) {
2010             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2011             duration = FFMAX(duration, duration1);
2012         }
2013     }
2014     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2015         start_time = start_time_text;
2016     if (start_time != INT64_MAX) {
2017         ic->start_time = start_time;
2018         if (end_time != INT64_MIN)
2019             duration = FFMAX(duration, end_time - start_time);
2020     }
2021     if (duration != INT64_MIN && ic->duration == AV_NOPTS_VALUE) {
2022         ic->duration = duration;
2023     }
2024         if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2025             /* compute the bitrate */
2026             ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
2027                 (double)ic->duration;
2028         }
2029 }
2030
2031 static void fill_all_stream_timings(AVFormatContext *ic)
2032 {
2033     int i;
2034     AVStream *st;
2035
2036     update_stream_timings(ic);
2037     for(i = 0;i < ic->nb_streams; i++) {
2038         st = ic->streams[i];
2039         if (st->start_time == AV_NOPTS_VALUE) {
2040             if(ic->start_time != AV_NOPTS_VALUE)
2041                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2042             if(ic->duration != AV_NOPTS_VALUE)
2043                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2044         }
2045     }
2046 }
2047
2048 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2049 {
2050     int64_t filesize, duration;
2051     int bit_rate, i;
2052     AVStream *st;
2053
2054     /* if bit_rate is already set, we believe it */
2055     if (ic->bit_rate <= 0) {
2056         bit_rate = 0;
2057         for(i=0;i<ic->nb_streams;i++) {
2058             st = ic->streams[i];
2059             if (st->codec->bit_rate > 0)
2060             bit_rate += st->codec->bit_rate;
2061         }
2062         ic->bit_rate = bit_rate;
2063     }
2064
2065     /* if duration is already set, we believe it */
2066     if (ic->duration == AV_NOPTS_VALUE &&
2067         ic->bit_rate != 0) {
2068         filesize = ic->pb ? avio_size(ic->pb) : 0;
2069         if (filesize > 0) {
2070             for(i = 0; i < ic->nb_streams; i++) {
2071                 st = ic->streams[i];
2072                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2073                 if (st->duration == AV_NOPTS_VALUE)
2074                     st->duration = duration;
2075             }
2076         }
2077     }
2078 }
2079
2080 #define DURATION_MAX_READ_SIZE 250000
2081 #define DURATION_MAX_RETRY 3
2082
2083 /* only usable for MPEG-PS streams */
2084 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2085 {
2086     AVPacket pkt1, *pkt = &pkt1;
2087     AVStream *st;
2088     int read_size, i, ret;
2089     int64_t end_time;
2090     int64_t filesize, offset, duration;
2091     int retry=0;
2092
2093     /* flush packet queue */
2094     flush_packet_queue(ic);
2095
2096     for (i=0; i<ic->nb_streams; i++) {
2097         st = ic->streams[i];
2098         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2099             av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2100
2101         if (st->parser) {
2102             av_parser_close(st->parser);
2103             st->parser= NULL;
2104         }
2105     }
2106
2107     /* estimate the end time (duration) */
2108     /* XXX: may need to support wrapping */
2109     filesize = ic->pb ? avio_size(ic->pb) : 0;
2110     end_time = AV_NOPTS_VALUE;
2111     do{
2112         offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2113         if (offset < 0)
2114             offset = 0;
2115
2116         avio_seek(ic->pb, offset, SEEK_SET);
2117         read_size = 0;
2118         for(;;) {
2119             if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2120                 break;
2121
2122             do {
2123                 ret = ff_read_packet(ic, pkt);
2124             } while(ret == AVERROR(EAGAIN));
2125             if (ret != 0)
2126                 break;
2127             read_size += pkt->size;
2128             st = ic->streams[pkt->stream_index];
2129             if (pkt->pts != AV_NOPTS_VALUE &&
2130                 (st->start_time != AV_NOPTS_VALUE ||
2131                  st->first_dts  != AV_NOPTS_VALUE)) {
2132                 duration = end_time = pkt->pts;
2133                 if (st->start_time != AV_NOPTS_VALUE)
2134                     duration -= st->start_time;
2135                 else
2136                     duration -= st->first_dts;
2137                 if (duration < 0)
2138                     duration += 1LL<<st->pts_wrap_bits;
2139                 if (duration > 0) {
2140                     if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
2141                         st->duration = duration;
2142                 }
2143             }
2144             av_free_packet(pkt);
2145         }
2146     }while(   end_time==AV_NOPTS_VALUE
2147            && filesize > (DURATION_MAX_READ_SIZE<<retry)
2148            && ++retry <= DURATION_MAX_RETRY);
2149
2150     fill_all_stream_timings(ic);
2151
2152     avio_seek(ic->pb, old_offset, SEEK_SET);
2153     for (i=0; i<ic->nb_streams; i++) {
2154         st= ic->streams[i];
2155         st->cur_dts= st->first_dts;
2156         st->last_IP_pts = AV_NOPTS_VALUE;
2157         st->reference_dts = AV_NOPTS_VALUE;
2158     }
2159 }
2160
2161 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2162 {
2163     int64_t file_size;
2164
2165     /* get the file size, if possible */
2166     if (ic->iformat->flags & AVFMT_NOFILE) {
2167         file_size = 0;
2168     } else {
2169         file_size = avio_size(ic->pb);
2170         file_size = FFMAX(0, file_size);
2171     }
2172
2173     if ((!strcmp(ic->iformat->name, "mpeg") ||
2174          !strcmp(ic->iformat->name, "mpegts")) &&
2175         file_size && ic->pb->seekable) {
2176         /* get accurate estimate from the PTSes */
2177         estimate_timings_from_pts(ic, old_offset);
2178     } else if (has_duration(ic)) {
2179         /* at least one component has timings - we use them for all
2180            the components */
2181         fill_all_stream_timings(ic);
2182     } else {
2183         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2184         /* less precise: use bitrate info */
2185         estimate_timings_from_bit_rate(ic);
2186     }
2187     update_stream_timings(ic);
2188
2189     {
2190         int i;
2191         AVStream av_unused *st;
2192         for(i = 0;i < ic->nb_streams; i++) {
2193             st = ic->streams[i];
2194             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2195                     (double) st->start_time / AV_TIME_BASE,
2196                     (double) st->duration   / AV_TIME_BASE);
2197         }
2198         av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2199                 (double) ic->start_time / AV_TIME_BASE,
2200                 (double) ic->duration   / AV_TIME_BASE,
2201                 ic->bit_rate / 1000);
2202     }
2203 }
2204
2205 static int has_codec_parameters(AVStream *st)
2206 {
2207     AVCodecContext *avctx = st->codec;
2208     int val;
2209     switch (avctx->codec_type) {
2210     case AVMEDIA_TYPE_AUDIO:
2211         val = avctx->sample_rate && avctx->channels;
2212         if (!avctx->frame_size && determinable_frame_size(avctx))
2213             return 0;
2214         if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2215             return 0;
2216         break;
2217     case AVMEDIA_TYPE_VIDEO:
2218         val = avctx->width;
2219         if (st->info->found_decoder >= 0 && avctx->pix_fmt == PIX_FMT_NONE)
2220             return 0;
2221         break;
2222     case AVMEDIA_TYPE_DATA:
2223         if(avctx->codec_id == CODEC_ID_NONE) return 1;
2224     default:
2225         val = 1;
2226         break;
2227     }
2228     return avctx->codec_id != CODEC_ID_NONE && val != 0;
2229 }
2230
2231 static int has_decode_delay_been_guessed(AVStream *st)
2232 {
2233     return st->codec->codec_id != CODEC_ID_H264 ||
2234         st->info->nb_decoded_frames >= 6;
2235 }
2236
2237 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2238 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2239 {
2240     AVCodec *codec;
2241     int got_picture = 1, ret = 0;
2242     AVFrame picture;
2243     AVPacket pkt = *avpkt;
2244
2245     if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2246         AVDictionary *thread_opt = NULL;
2247
2248         codec = st->codec->codec ? st->codec->codec :
2249                                    avcodec_find_decoder(st->codec->codec_id);
2250
2251         if (!codec) {
2252             st->info->found_decoder = -1;
2253             return -1;
2254         }
2255
2256         /* force thread count to 1 since the h264 decoder will not extract SPS
2257          *  and PPS to extradata during multi-threaded decoding */
2258         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2259         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2260         if (!options)
2261             av_dict_free(&thread_opt);
2262         if (ret < 0) {
2263             st->info->found_decoder = -1;
2264             return ret;
2265         }
2266         st->info->found_decoder = 1;
2267     } else if (!st->info->found_decoder)
2268         st->info->found_decoder = 1;
2269
2270     if (st->info->found_decoder < 0)
2271         return -1;
2272
2273     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2274            ret >= 0 &&
2275            (!has_codec_parameters(st)         ||
2276            !has_decode_delay_been_guessed(st) ||
2277            (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2278         got_picture = 0;
2279         avcodec_get_frame_defaults(&picture);
2280         switch(st->codec->codec_type) {
2281         case AVMEDIA_TYPE_VIDEO:
2282             ret = avcodec_decode_video2(st->codec, &picture,
2283                                         &got_picture, &pkt);
2284             break;
2285         case AVMEDIA_TYPE_AUDIO:
2286             ret = avcodec_decode_audio4(st->codec, &picture, &got_picture, &pkt);
2287             break;
2288         default:
2289             break;
2290         }
2291         if (ret >= 0) {
2292             if (got_picture)
2293                 st->info->nb_decoded_frames++;
2294             pkt.data += ret;
2295             pkt.size -= ret;
2296             ret       = got_picture;
2297         }
2298     }
2299     if(!pkt.data && !got_picture)
2300         return -1;
2301     return ret;
2302 }
2303
2304 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2305 {
2306     while (tags->id != CODEC_ID_NONE) {
2307         if (tags->id == id)
2308             return tags->tag;
2309         tags++;
2310     }
2311     return 0;
2312 }
2313
2314 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2315 {
2316     int i;
2317     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2318         if(tag == tags[i].tag)
2319             return tags[i].id;
2320     }
2321     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2322         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2323             return tags[i].id;
2324     }
2325     return CODEC_ID_NONE;
2326 }
2327
2328 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2329 {
2330     int i;
2331     for(i=0; tags && tags[i]; i++){
2332         int tag= ff_codec_get_tag(tags[i], id);
2333         if(tag) return tag;
2334     }
2335     return 0;
2336 }
2337
2338 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2339 {
2340     int i;
2341     for(i=0; tags && tags[i]; i++){
2342         enum CodecID id= ff_codec_get_id(tags[i], tag);
2343         if(id!=CODEC_ID_NONE) return id;
2344     }
2345     return CODEC_ID_NONE;
2346 }
2347
2348 static void compute_chapters_end(AVFormatContext *s)
2349 {
2350     unsigned int i, j;
2351     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2352
2353     for (i = 0; i < s->nb_chapters; i++)
2354         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2355             AVChapter *ch = s->chapters[i];
2356             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2357                                      : INT64_MAX;
2358
2359             for (j = 0; j < s->nb_chapters; j++) {
2360                 AVChapter *ch1 = s->chapters[j];
2361                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2362                 if (j != i && next_start > ch->start && next_start < end)
2363                     end = next_start;
2364             }
2365             ch->end = (end == INT64_MAX) ? ch->start : end;
2366         }
2367 }
2368
2369 static int get_std_framerate(int i){
2370     if(i<60*12) return i*1001;
2371     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2372 }
2373
2374 /*
2375  * Is the time base unreliable.
2376  * This is a heuristic to balance between quick acceptance of the values in
2377  * the headers vs. some extra checks.
2378  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2379  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2380  * And there are "variable" fps files this needs to detect as well.
2381  */
2382 static int tb_unreliable(AVCodecContext *c){
2383     if(   c->time_base.den >= 101L*c->time_base.num
2384        || c->time_base.den <    5L*c->time_base.num
2385 /*       || c->codec_tag == AV_RL32("DIVX")
2386        || c->codec_tag == AV_RL32("XVID")*/
2387        || c->codec_id == CODEC_ID_MPEG2VIDEO
2388        || c->codec_id == CODEC_ID_H264
2389        )
2390         return 1;
2391     return 0;
2392 }
2393
2394 #if FF_API_FORMAT_PARAMETERS
2395 int av_find_stream_info(AVFormatContext *ic)
2396 {
2397     return avformat_find_stream_info(ic, NULL);
2398 }
2399 #endif
2400
2401 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2402 {
2403     int i, count, ret, read_size, j;
2404     AVStream *st;
2405     AVPacket pkt1, *pkt;
2406     int64_t old_offset = avio_tell(ic->pb);
2407     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2408     int flush_codecs = 1;
2409
2410     for(i=0;i<ic->nb_streams;i++) {
2411         AVCodec *codec;
2412         AVDictionary *thread_opt = NULL;
2413         st = ic->streams[i];
2414
2415         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2416             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2417 /*            if(!st->time_base.num)
2418                 st->time_base= */
2419             if(!st->codec->time_base.num)
2420                 st->codec->time_base= st->time_base;
2421         }
2422         //only for the split stuff
2423         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2424             st->parser = av_parser_init(st->codec->codec_id);
2425             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2426                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2427             }
2428         }
2429         codec = st->codec->codec ? st->codec->codec :
2430                                    avcodec_find_decoder(st->codec->codec_id);
2431
2432         /* force thread count to 1 since the h264 decoder will not extract SPS
2433          *  and PPS to extradata during multi-threaded decoding */
2434         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2435
2436         /* Ensure that subtitle_header is properly set. */
2437         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2438             && codec && !st->codec->codec)
2439             avcodec_open2(st->codec, codec, options ? &options[i]
2440                               : &thread_opt);
2441
2442         //try to just open decoders, in case this is enough to get parameters
2443         if (!has_codec_parameters(st)) {
2444             if (codec && !st->codec->codec)
2445                 avcodec_open2(st->codec, codec, options ? &options[i]
2446                               : &thread_opt);
2447         }
2448         if (!options)
2449             av_dict_free(&thread_opt);
2450     }
2451
2452     for (i=0; i<ic->nb_streams; i++) {
2453         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2454     }
2455
2456     count = 0;
2457     read_size = 0;
2458     for(;;) {
2459         if (ff_check_interrupt(&ic->interrupt_callback)){
2460             ret= AVERROR_EXIT;
2461             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2462             break;
2463         }
2464
2465         /* check if one codec still needs to be handled */
2466         for(i=0;i<ic->nb_streams;i++) {
2467             int fps_analyze_framecount = 20;
2468
2469             st = ic->streams[i];
2470             if (!has_codec_parameters(st))
2471                 break;
2472             /* if the timebase is coarse (like the usual millisecond precision
2473                of mkv), we need to analyze more frames to reliably arrive at
2474                the correct fps */
2475             if (av_q2d(st->time_base) > 0.0005)
2476                 fps_analyze_framecount *= 2;
2477             if (ic->fps_probe_size >= 0)
2478                 fps_analyze_framecount = ic->fps_probe_size;
2479             /* variable fps and no guess at the real fps */
2480             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2481                && st->info->duration_count < fps_analyze_framecount
2482                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2483                 break;
2484             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2485                 break;
2486             if (st->first_dts == AV_NOPTS_VALUE &&
2487                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2488                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2489                 break;
2490         }
2491         if (i == ic->nb_streams) {
2492             /* NOTE: if the format has no header, then we need to read
2493                some packets to get most of the streams, so we cannot
2494                stop here */
2495             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2496                 /* if we found the info for all the codecs, we can stop */
2497                 ret = count;
2498                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2499                 flush_codecs = 0;
2500                 break;
2501             }
2502         }
2503         /* we did not get all the codec info, but we read too much data */
2504         if (read_size >= ic->probesize) {
2505             ret = count;
2506             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2507             break;
2508         }
2509
2510         /* NOTE: a new stream can be added there if no header in file
2511            (AVFMTCTX_NOHEADER) */
2512         ret = read_frame_internal(ic, &pkt1);
2513         if (ret == AVERROR(EAGAIN))
2514             continue;
2515
2516         if (ret < 0) {
2517             /* EOF or error*/
2518             break;
2519         }
2520
2521         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2522         if ((ret = av_dup_packet(pkt)) < 0)
2523             goto find_stream_info_err;
2524
2525         read_size += pkt->size;
2526
2527         st = ic->streams[pkt->stream_index];
2528         if (st->codec_info_nb_frames>1) {
2529             int64_t t=0;
2530             if (st->time_base.den > 0)
2531                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2532             if (st->avg_frame_rate.num > 0)
2533                 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));
2534
2535             if (t >= ic->max_analyze_duration) {
2536                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64"\n", ic->max_analyze_duration, t);
2537                 break;
2538             }
2539             st->info->codec_info_duration += pkt->duration;
2540         }
2541         {
2542             int64_t last = st->info->last_dts;
2543
2544             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
2545                 double dts= (is_relative(pkt->dts) ?  pkt->dts - RELATIVE_TS_BASE : pkt->dts) * av_q2d(st->time_base);
2546                 int64_t duration= pkt->dts - last;
2547
2548 //                 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2549 //                     av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2550                 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); i++) {
2551                     int framerate= get_std_framerate(i);
2552                     double sdts= dts*framerate/(1001*12);
2553                     for(j=0; j<2; j++){
2554                         int ticks= lrintf(sdts+j*0.5);
2555                         double error= sdts - ticks + j*0.5;
2556                         st->info->duration_error[j][0][i] += error;
2557                         st->info->duration_error[j][1][i] += error*error;
2558                     }
2559                 }
2560                 st->info->duration_count++;
2561                 // ignore the first 4 values, they might have some random jitter
2562                 if (st->info->duration_count > 3)
2563                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2564             }
2565             if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2566                 st->info->last_dts = pkt->dts;
2567         }
2568         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2569             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2570             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2571                 st->codec->extradata_size= i;
2572                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2573                 if (!st->codec->extradata)
2574                     return AVERROR(ENOMEM);
2575                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2576                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2577             }
2578         }
2579
2580         /* if still no information, we try to open the codec and to
2581            decompress the frame. We try to avoid that in most cases as
2582            it takes longer and uses more memory. For MPEG-4, we need to
2583            decompress for QuickTime.
2584
2585            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2586            least one frame of codec data, this makes sure the codec initializes
2587            the channel configuration and does not only trust the values from the container.
2588         */
2589         try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2590
2591         st->codec_info_nb_frames++;
2592         count++;
2593     }
2594
2595     if (flush_codecs) {
2596         AVPacket empty_pkt = { 0 };
2597         int err = 0;
2598         av_init_packet(&empty_pkt);
2599
2600         ret = -1; /* we could not have all the codec parameters before EOF */
2601         for(i=0;i<ic->nb_streams;i++) {
2602             st = ic->streams[i];
2603
2604             /* flush the decoders */
2605             if (st->info->found_decoder == 1) {
2606                 do {
2607                     err = try_decode_frame(st, &empty_pkt,
2608                                             (options && i < orig_nb_streams) ?
2609                                             &options[i] : NULL);
2610                 } while (err > 0 && !has_codec_parameters(st));
2611
2612                 if (err < 0) {
2613                     av_log(ic, AV_LOG_INFO,
2614                         "decoding for stream %d failed\n", st->index);
2615                 }
2616             }
2617
2618             if (!has_codec_parameters(st)){
2619                 char buf[256];
2620                 avcodec_string(buf, sizeof(buf), st->codec, 0);
2621                 av_log(ic, AV_LOG_WARNING,
2622                        "Could not find codec parameters (%s)\n", buf);
2623             } else {
2624                 ret = 0;
2625             }
2626         }
2627     }
2628
2629     // close codecs which were opened in try_decode_frame()
2630     for(i=0;i<ic->nb_streams;i++) {
2631         st = ic->streams[i];
2632         avcodec_close(st->codec);
2633     }
2634     for(i=0;i<ic->nb_streams;i++) {
2635         st = ic->streams[i];
2636         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2637             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2638                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2639                 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2640                     st->codec->codec_tag= tag;
2641             }
2642
2643             if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2644                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2645                           (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2646                           st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2647             // the check for tb_unreliable() is not completely correct, since this is not about handling
2648             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2649             // ipmovie.c produces.
2650             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)
2651                 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);
2652             if (st->info->duration_count && !st->r_frame_rate.num
2653                && tb_unreliable(st->codec) /*&&
2654                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2655                st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2656                 int num = 0;
2657                 double best_error= 0.01;
2658
2659                 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); j++) {
2660                     int k;
2661
2662                     if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2663                         continue;
2664                     if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2665                         continue;
2666                     for(k=0; k<2; k++){
2667                         int n= st->info->duration_count;
2668                         double a= st->info->duration_error[k][0][j] / n;
2669                         double error= st->info->duration_error[k][1][j]/n - a*a;
2670
2671                         if(error < best_error && best_error> 0.000000001){
2672                             best_error= error;
2673                             num = get_std_framerate(j);
2674                         }
2675                         if(error < 0.02)
2676                             av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2677                     }
2678                 }
2679                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2680                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2681                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2682             }
2683
2684             if (!st->r_frame_rate.num){
2685                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2686                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2687                     st->r_frame_rate.num = st->codec->time_base.den;
2688                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2689                 }else{
2690                     st->r_frame_rate.num = st->time_base.den;
2691                     st->r_frame_rate.den = st->time_base.num;
2692                 }
2693             }
2694         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2695             if(!st->codec->bits_per_coded_sample)
2696                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2697             // set stream disposition based on audio service type
2698             switch (st->codec->audio_service_type) {
2699             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2700                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2701             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2702                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2703             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2704                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2705             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2706                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2707             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2708                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2709             }
2710         }
2711     }
2712
2713     estimate_timings(ic, old_offset);
2714
2715     compute_chapters_end(ic);
2716
2717  find_stream_info_err:
2718     for (i=0; i < ic->nb_streams; i++) {
2719         if (ic->streams[i]->codec)
2720             ic->streams[i]->codec->thread_count = 0;
2721         av_freep(&ic->streams[i]->info);
2722     }
2723     return ret;
2724 }
2725
2726 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
2727 {
2728     int i, j;
2729
2730     for (i = 0; i < ic->nb_programs; i++) {
2731         if (ic->programs[i] == last) {
2732             last = NULL;
2733         } else {
2734             if (!last)
2735                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2736                     if (ic->programs[i]->stream_index[j] == s)
2737                         return ic->programs[i];
2738         }
2739     }
2740     return NULL;
2741 }
2742
2743 int av_find_best_stream(AVFormatContext *ic,
2744                         enum AVMediaType type,
2745                         int wanted_stream_nb,
2746                         int related_stream,
2747                         AVCodec **decoder_ret,
2748                         int flags)
2749 {
2750     int i, nb_streams = ic->nb_streams;
2751     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2752     unsigned *program = NULL;
2753     AVCodec *decoder = NULL, *best_decoder = NULL;
2754
2755     if (related_stream >= 0 && wanted_stream_nb < 0) {
2756         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
2757         if (p) {
2758             program = p->stream_index;
2759             nb_streams = p->nb_stream_indexes;
2760         }
2761     }
2762     for (i = 0; i < nb_streams; i++) {
2763         int real_stream_index = program ? program[i] : i;
2764         AVStream *st = ic->streams[real_stream_index];
2765         AVCodecContext *avctx = st->codec;
2766         if (avctx->codec_type != type)
2767             continue;
2768         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2769             continue;
2770         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2771             continue;
2772         if (decoder_ret) {
2773             decoder = avcodec_find_decoder(st->codec->codec_id);
2774             if (!decoder) {
2775                 if (ret < 0)
2776                     ret = AVERROR_DECODER_NOT_FOUND;
2777                 continue;
2778             }
2779         }
2780         if (best_count >= st->codec_info_nb_frames)
2781             continue;
2782         best_count = st->codec_info_nb_frames;
2783         ret = real_stream_index;
2784         best_decoder = decoder;
2785         if (program && i == nb_streams - 1 && ret < 0) {
2786             program = NULL;
2787             nb_streams = ic->nb_streams;
2788             i = 0; /* no related stream found, try again with everything */
2789         }
2790     }
2791     if (decoder_ret)
2792         *decoder_ret = best_decoder;
2793     return ret;
2794 }
2795
2796 /*******************************************************/
2797
2798 int av_read_play(AVFormatContext *s)
2799 {
2800     if (s->iformat->read_play)
2801         return s->iformat->read_play(s);
2802     if (s->pb)
2803         return avio_pause(s->pb, 0);
2804     return AVERROR(ENOSYS);
2805 }
2806
2807 int av_read_pause(AVFormatContext *s)
2808 {
2809     if (s->iformat->read_pause)
2810         return s->iformat->read_pause(s);
2811     if (s->pb)
2812         return avio_pause(s->pb, 1);
2813     return AVERROR(ENOSYS);
2814 }
2815
2816 void avformat_free_context(AVFormatContext *s)
2817 {
2818     int i;
2819     AVStream *st;
2820
2821     av_opt_free(s);
2822     if (s->iformat && s->iformat->priv_class && s->priv_data)
2823         av_opt_free(s->priv_data);
2824
2825     for(i=0;i<s->nb_streams;i++) {
2826         /* free all data in a stream component */
2827         st = s->streams[i];
2828         if (st->parser) {
2829             av_parser_close(st->parser);
2830         }
2831         if (st->attached_pic.data)
2832             av_free_packet(&st->attached_pic);
2833         av_dict_free(&st->metadata);
2834         av_freep(&st->index_entries);
2835         av_freep(&st->codec->extradata);
2836         av_freep(&st->codec->subtitle_header);
2837         av_freep(&st->codec);
2838         av_freep(&st->priv_data);
2839         av_freep(&st->info);
2840         av_freep(&st);
2841     }
2842     for(i=s->nb_programs-1; i>=0; i--) {
2843         av_dict_free(&s->programs[i]->metadata);
2844         av_freep(&s->programs[i]->stream_index);
2845         av_freep(&s->programs[i]);
2846     }
2847     av_freep(&s->programs);
2848     av_freep(&s->priv_data);
2849     while(s->nb_chapters--) {
2850         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2851         av_freep(&s->chapters[s->nb_chapters]);
2852     }
2853     av_freep(&s->chapters);
2854     av_dict_free(&s->metadata);
2855     av_freep(&s->streams);
2856     av_free(s);
2857 }
2858
2859 #if FF_API_CLOSE_INPUT_FILE
2860 void av_close_input_file(AVFormatContext *s)
2861 {
2862     avformat_close_input(&s);
2863 }
2864 #endif
2865
2866 void avformat_close_input(AVFormatContext **ps)
2867 {
2868     AVFormatContext *s = *ps;
2869     AVIOContext *pb = (s->iformat && (s->iformat->flags & AVFMT_NOFILE)) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2870                        NULL : s->pb;
2871     flush_packet_queue(s);
2872     if (s->iformat && (s->iformat->read_close))
2873         s->iformat->read_close(s);
2874     avformat_free_context(s);
2875     *ps = NULL;
2876     if (pb)
2877         avio_close(pb);
2878 }
2879
2880 #if FF_API_NEW_STREAM
2881 AVStream *av_new_stream(AVFormatContext *s, int id)
2882 {
2883     AVStream *st = avformat_new_stream(s, NULL);
2884     if (st)
2885         st->id = id;
2886     return st;
2887 }
2888 #endif
2889
2890 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2891 {
2892     AVStream *st;
2893     int i;
2894     AVStream **streams;
2895
2896     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2897         return NULL;
2898     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2899     if (!streams)
2900         return NULL;
2901     s->streams = streams;
2902
2903     st = av_mallocz(sizeof(AVStream));
2904     if (!st)
2905         return NULL;
2906     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2907         av_free(st);
2908         return NULL;
2909     }
2910     st->info->last_dts = AV_NOPTS_VALUE;
2911
2912     st->codec = avcodec_alloc_context3(c);
2913     if (s->iformat) {
2914         /* no default bitrate if decoding */
2915         st->codec->bit_rate = 0;
2916     }
2917     st->index = s->nb_streams;
2918     st->start_time = AV_NOPTS_VALUE;
2919     st->duration = AV_NOPTS_VALUE;
2920         /* we set the current DTS to 0 so that formats without any timestamps
2921            but durations get some timestamps, formats with some unknown
2922            timestamps have their first few packets buffered and the
2923            timestamps corrected before they are returned to the user */
2924     st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
2925     st->first_dts = AV_NOPTS_VALUE;
2926     st->probe_packets = MAX_PROBE_PACKETS;
2927
2928     /* default pts setting is MPEG-like */
2929     avpriv_set_pts_info(st, 33, 1, 90000);
2930     st->last_IP_pts = AV_NOPTS_VALUE;
2931     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2932         st->pts_buffer[i]= AV_NOPTS_VALUE;
2933     st->reference_dts = AV_NOPTS_VALUE;
2934
2935     st->sample_aspect_ratio = (AVRational){0,1};
2936
2937     s->streams[s->nb_streams++] = st;
2938     return st;
2939 }
2940
2941 AVProgram *av_new_program(AVFormatContext *ac, int id)
2942 {
2943     AVProgram *program=NULL;
2944     int i;
2945
2946     av_dlog(ac, "new_program: id=0x%04x\n", id);
2947
2948     for(i=0; i<ac->nb_programs; i++)
2949         if(ac->programs[i]->id == id)
2950             program = ac->programs[i];
2951
2952     if(!program){
2953         program = av_mallocz(sizeof(AVProgram));
2954         if (!program)
2955             return NULL;
2956         dynarray_add(&ac->programs, &ac->nb_programs, program);
2957         program->discard = AVDISCARD_NONE;
2958     }
2959     program->id = id;
2960
2961     return program;
2962 }
2963
2964 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2965 {
2966     AVChapter *chapter = NULL;
2967     int i;
2968
2969     for(i=0; i<s->nb_chapters; i++)
2970         if(s->chapters[i]->id == id)
2971             chapter = s->chapters[i];
2972
2973     if(!chapter){
2974         chapter= av_mallocz(sizeof(AVChapter));
2975         if(!chapter)
2976             return NULL;
2977         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2978     }
2979     av_dict_set(&chapter->metadata, "title", title, 0);
2980     chapter->id    = id;
2981     chapter->time_base= time_base;
2982     chapter->start = start;
2983     chapter->end   = end;
2984
2985     return chapter;
2986 }
2987
2988 /************************************************************/
2989 /* output media file */
2990
2991 int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
2992                                    const char *format, const char *filename)
2993 {
2994     AVFormatContext *s = avformat_alloc_context();
2995     int ret = 0;
2996
2997     *avctx = NULL;
2998     if (!s)
2999         goto nomem;
3000
3001     if (!oformat) {
3002         if (format) {
3003             oformat = av_guess_format(format, NULL, NULL);
3004             if (!oformat) {
3005                 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
3006                 ret = AVERROR(EINVAL);
3007                 goto error;
3008             }
3009         } else {
3010             oformat = av_guess_format(NULL, filename, NULL);
3011             if (!oformat) {
3012                 ret = AVERROR(EINVAL);
3013                 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
3014                        filename);
3015                 goto error;
3016             }
3017         }
3018     }
3019
3020     s->oformat = oformat;
3021     if (s->oformat->priv_data_size > 0) {
3022         s->priv_data = av_mallocz(s->oformat->priv_data_size);
3023         if (!s->priv_data)
3024             goto nomem;
3025         if (s->oformat->priv_class) {
3026             *(const AVClass**)s->priv_data= s->oformat->priv_class;
3027             av_opt_set_defaults(s->priv_data);
3028         }
3029     } else
3030         s->priv_data = NULL;
3031
3032     if (filename)
3033         av_strlcpy(s->filename, filename, sizeof(s->filename));
3034     *avctx = s;
3035     return 0;
3036 nomem:
3037     av_log(s, AV_LOG_ERROR, "Out of memory\n");
3038     ret = AVERROR(ENOMEM);
3039 error:
3040     avformat_free_context(s);
3041     return ret;
3042 }
3043
3044 #if FF_API_ALLOC_OUTPUT_CONTEXT
3045 AVFormatContext *avformat_alloc_output_context(const char *format,
3046                                                AVOutputFormat *oformat, const char *filename)
3047 {
3048     AVFormatContext *avctx;
3049     int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
3050     return ret < 0 ? NULL : avctx;
3051 }
3052 #endif
3053
3054 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
3055 {
3056     const AVCodecTag *avctag;
3057     int n;
3058     enum CodecID id = CODEC_ID_NONE;
3059     unsigned int tag = 0;
3060
3061     /**
3062      * Check that tag + id is in the table
3063      * If neither is in the table -> OK
3064      * If tag is in the table with another id -> FAIL
3065      * If id is in the table with another tag -> FAIL unless strict < normal
3066      */
3067     for (n = 0; s->oformat->codec_tag[n]; n++) {
3068         avctag = s->oformat->codec_tag[n];
3069         while (avctag->id != CODEC_ID_NONE) {
3070             if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
3071                 id = avctag->id;
3072                 if (id == st->codec->codec_id)
3073                     return 1;
3074             }
3075             if (avctag->id == st->codec->codec_id)
3076                 tag = avctag->tag;
3077             avctag++;
3078         }
3079     }
3080     if (id != CODEC_ID_NONE)
3081         return 0;
3082     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
3083         return 0;
3084     return 1;
3085 }
3086
3087 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
3088 {
3089     int ret = 0, i;
3090     AVStream *st;
3091     AVDictionary *tmp = NULL;
3092
3093     if (options)
3094         av_dict_copy(&tmp, *options, 0);
3095     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
3096         goto fail;
3097     if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
3098         (ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3099         goto fail;
3100
3101     // some sanity checks
3102     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
3103         av_log(s, AV_LOG_ERROR, "no streams\n");
3104         ret = AVERROR(EINVAL);
3105         goto fail;
3106     }
3107
3108     for(i=0;i<s->nb_streams;i++) {
3109         st = s->streams[i];
3110
3111         switch (st->codec->codec_type) {
3112         case AVMEDIA_TYPE_AUDIO:
3113             if(st->codec->sample_rate<=0){
3114                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
3115                 ret = AVERROR(EINVAL);
3116                 goto fail;
3117             }
3118             if(!st->codec->block_align)
3119                 st->codec->block_align = st->codec->channels *
3120                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
3121             break;
3122         case AVMEDIA_TYPE_VIDEO:
3123             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
3124                 av_log(s, AV_LOG_ERROR, "time base not set\n");
3125                 ret = AVERROR(EINVAL);
3126                 goto fail;
3127             }
3128             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
3129                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
3130                 ret = AVERROR(EINVAL);
3131                 goto fail;
3132             }
3133             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)
3134                && FFABS(av_q2d(st->sample_aspect_ratio) - av_q2d(st->codec->sample_aspect_ratio)) > 0.004*av_q2d(st->sample_aspect_ratio)
3135             ){
3136                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between muxer "
3137                        "(%d/%d) and encoder layer (%d/%d)\n",
3138                        st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3139                        st->codec->sample_aspect_ratio.num,
3140                        st->codec->sample_aspect_ratio.den);
3141                 ret = AVERROR(EINVAL);
3142                 goto fail;
3143             }
3144             break;
3145         }
3146
3147         if(s->oformat->codec_tag){
3148             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)){
3149                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
3150                 st->codec->codec_tag= 0;
3151             }
3152             if(st->codec->codec_tag){
3153                 if (!validate_codec_tag(s, st)) {
3154                     char tagbuf[32];
3155                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
3156                     av_log(s, AV_LOG_ERROR,
3157                            "Tag %s/0x%08x incompatible with output codec id '%d'\n",
3158                            tagbuf, st->codec->codec_tag, st->codec->codec_id);
3159                     ret = AVERROR_INVALIDDATA;
3160                     goto fail;
3161                 }
3162             }else
3163                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
3164         }
3165
3166         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
3167             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
3168           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
3169     }
3170
3171     if (!s->priv_data && s->oformat->priv_data_size > 0) {
3172         s->priv_data = av_mallocz(s->oformat->priv_data_size);
3173         if (!s->priv_data) {
3174             ret = AVERROR(ENOMEM);
3175             goto fail;
3176         }
3177         if (s->oformat->priv_class) {
3178             *(const AVClass**)s->priv_data= s->oformat->priv_class;
3179             av_opt_set_defaults(s->priv_data);
3180             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3181                 goto fail;
3182         }
3183     }
3184
3185     /* set muxer identification string */
3186     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
3187         av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
3188     }
3189
3190     if(s->oformat->write_header){
3191         ret = s->oformat->write_header(s);
3192         if (ret < 0)
3193             goto fail;
3194     }
3195
3196     /* init PTS generation */
3197     for(i=0;i<s->nb_streams;i++) {
3198         int64_t den = AV_NOPTS_VALUE;
3199         st = s->streams[i];
3200
3201         switch (st->codec->codec_type) {
3202         case AVMEDIA_TYPE_AUDIO:
3203             den = (int64_t)st->time_base.num * st->codec->sample_rate;
3204             break;
3205         case AVMEDIA_TYPE_VIDEO:
3206             den = (int64_t)st->time_base.num * st->codec->time_base.den;
3207             break;
3208         default:
3209             break;
3210         }
3211         if (den != AV_NOPTS_VALUE) {
3212             if (den <= 0) {
3213                 ret = AVERROR_INVALIDDATA;
3214                 goto fail;
3215             }
3216             frac_init(&st->pts, 0, 0, den);
3217         }
3218     }
3219
3220     if (options) {
3221         av_dict_free(options);
3222         *options = tmp;
3223     }
3224     return 0;
3225 fail:
3226     av_dict_free(&tmp);
3227     return ret;
3228 }
3229
3230 //FIXME merge with compute_pkt_fields
3231 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3232     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3233     int num, den, frame_size, i;
3234
3235     av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3236             pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3237
3238     /* duration field */
3239     if (pkt->duration == 0) {
3240         compute_frame_duration(&num, &den, st, NULL, pkt);
3241         if (den && num) {
3242             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3243         }
3244     }
3245
3246     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3247         pkt->pts= pkt->dts;
3248
3249     //XXX/FIXME this is a temporary hack until all encoders output pts
3250     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3251         static int warned;
3252         if (!warned) {
3253             av_log(s, AV_LOG_WARNING, "Encoder did not produce proper pts, making some up.\n");
3254             warned = 1;
3255         }
3256         pkt->dts=
3257 //        pkt->pts= st->cur_dts;
3258         pkt->pts= st->pts.val;
3259     }
3260
3261     //calculate dts from pts
3262     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3263         st->pts_buffer[0]= pkt->pts;
3264         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3265             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3266         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3267             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3268
3269         pkt->dts= st->pts_buffer[0];
3270     }
3271
3272     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)){
3273         av_log(s, AV_LOG_ERROR,
3274                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3275                st->index, st->cur_dts, pkt->dts);
3276         return AVERROR(EINVAL);
3277     }
3278     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3279         av_log(s, AV_LOG_ERROR, "pts (%"PRId64") < dts (%"PRId64") in stream %d\n", pkt->pts, pkt->dts, st->index);
3280         return AVERROR(EINVAL);
3281     }
3282
3283 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3284     st->cur_dts= pkt->dts;
3285     st->pts.val= pkt->dts;
3286
3287     /* update pts */
3288     switch (st->codec->codec_type) {
3289     case AVMEDIA_TYPE_AUDIO:
3290         frame_size = get_audio_frame_size(st->codec, pkt->size, 1);
3291
3292         /* HACK/FIXME, we skip the initial 0 size packets as they are most
3293            likely equal to the encoder delay, but it would be better if we
3294            had the real timestamps from the encoder */
3295         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3296             frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3297         }
3298         break;
3299     case AVMEDIA_TYPE_VIDEO:
3300         frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3301         break;
3302     default:
3303         break;
3304     }
3305     return 0;
3306 }
3307
3308 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3309 {
3310     int ret;
3311
3312     if (!pkt) {
3313         if (s->oformat->flags & AVFMT_ALLOW_FLUSH)
3314             return s->oformat->write_packet(s, pkt);
3315         return 1;
3316     }
3317
3318     ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3319
3320     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3321         return ret;
3322
3323     ret= s->oformat->write_packet(s, pkt);
3324
3325     if (ret >= 0)
3326         s->streams[pkt->stream_index]->nb_frames++;
3327     return ret;
3328 }
3329
3330 #define CHUNK_START 0x1000
3331
3332 int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3333                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3334 {
3335     AVPacketList **next_point, *this_pktl;
3336     AVStream *st= s->streams[pkt->stream_index];
3337     int chunked= s->max_chunk_size || s->max_chunk_duration;
3338
3339     this_pktl = av_mallocz(sizeof(AVPacketList));
3340     if (!this_pktl)
3341         return AVERROR(ENOMEM);
3342     this_pktl->pkt= *pkt;
3343     pkt->destruct= NULL;             // do not free original but only the copy
3344     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3345
3346     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3347         next_point = &(st->last_in_packet_buffer->next);
3348     }else{
3349         next_point = &s->packet_buffer;
3350     }
3351
3352     if(*next_point){
3353         if(chunked){
3354             uint64_t max= av_rescale_q(s->max_chunk_duration, AV_TIME_BASE_Q, st->time_base);
3355             if(   st->interleaver_chunk_size     + pkt->size     <= s->max_chunk_size-1U
3356                && st->interleaver_chunk_duration + pkt->duration <= max-1U){
3357                 st->interleaver_chunk_size     += pkt->size;
3358                 st->interleaver_chunk_duration += pkt->duration;
3359                 goto next_non_null;
3360             }else{
3361                 st->interleaver_chunk_size     =