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