]> git.sesse.net Git - ffmpeg/blob - libavformat/utils.c
Merge commit '058d5f2feb730846f22c1812e433f92f670ad751'
[ffmpeg] / 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 #include <stdint.h>
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/opt.h"
31 #include "libavutil/dict.h"
32 #include "libavutil/internal.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 "libavutil/time.h"
41 #include "libavutil/timestamp.h"
42 #include "riff.h"
43 #include "audiointerleave.h"
44 #include "url.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 /**
82  * Wrap a given time stamp, if there is an indication for an overflow
83  *
84  * @param st stream
85  * @param timestamp the time stamp to wrap
86  * @return resulting time stamp
87  */
88 static int64_t wrap_timestamp(AVStream *st, int64_t timestamp)
89 {
90     if (st->pts_wrap_behavior != AV_PTS_WRAP_IGNORE &&
91         st->pts_wrap_reference != AV_NOPTS_VALUE && timestamp != AV_NOPTS_VALUE) {
92         if (st->pts_wrap_behavior == AV_PTS_WRAP_ADD_OFFSET &&
93             timestamp < st->pts_wrap_reference)
94             return timestamp + (1ULL<<st->pts_wrap_bits);
95         else if (st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET &&
96             timestamp >= st->pts_wrap_reference)
97             return timestamp - (1ULL<<st->pts_wrap_bits);
98     }
99     return timestamp;
100 }
101
102 MAKE_ACCESSORS(AVStream, stream, AVRational, r_frame_rate)
103 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, video_codec)
104 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, audio_codec)
105 MAKE_ACCESSORS(AVFormatContext, format, AVCodec *, subtitle_codec)
106
107 static AVCodec *find_decoder(AVFormatContext *s, AVStream *st, enum AVCodecID codec_id)
108 {
109     if (st->codec->codec)
110         return st->codec->codec;
111
112     switch(st->codec->codec_type){
113     case AVMEDIA_TYPE_VIDEO:
114         if(s->video_codec)    return s->video_codec;
115         break;
116     case AVMEDIA_TYPE_AUDIO:
117         if(s->audio_codec)    return s->audio_codec;
118         break;
119     case AVMEDIA_TYPE_SUBTITLE:
120         if(s->subtitle_codec) return s->subtitle_codec;
121         break;
122     }
123
124     return avcodec_find_decoder(codec_id);
125 }
126
127 int av_format_get_probe_score(const AVFormatContext *s)
128 {
129     return s->probe_score;
130 }
131
132 /* an arbitrarily chosen "sane" max packet size -- 50M */
133 #define SANE_CHUNK_SIZE (50000000)
134
135 int ffio_limit(AVIOContext *s, int size)
136 {
137     if(s->maxsize>=0){
138         int64_t remaining= s->maxsize - avio_tell(s);
139         if(remaining < size){
140             int64_t newsize= avio_size(s);
141             if(!s->maxsize || s->maxsize<newsize)
142                 s->maxsize= newsize - !newsize;
143             remaining= s->maxsize - avio_tell(s);
144             remaining= FFMAX(remaining, 0);
145         }
146
147         if(s->maxsize>=0 && remaining+1 < size){
148             av_log(NULL, remaining ? AV_LOG_ERROR : AV_LOG_DEBUG, "Truncating packet of size %d to %"PRId64"\n", size, remaining+1);
149             size= remaining+1;
150         }
151     }
152     return size;
153 }
154
155 /*
156  * Read the data in sane-sized chunks and append to pkt.
157  * Return the number of bytes read or an error.
158  */
159 static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
160 {
161     int64_t orig_pos   = pkt->pos; // av_grow_packet might reset pos
162     int orig_size      = pkt->size;
163     int ret;
164
165     do {
166         int prev_size = pkt->size;
167         int read_size;
168
169         /*
170          * When the caller requests a lot of data, limit it to the amount left
171          * in file or SANE_CHUNK_SIZE when it is not known
172          */
173         read_size = size;
174         if (read_size > SANE_CHUNK_SIZE/10) {
175             read_size = ffio_limit(s, read_size);
176             // If filesize/maxsize is unknown, limit to SANE_CHUNK_SIZE
177             if (s->maxsize < 0)
178                 read_size = FFMIN(read_size, SANE_CHUNK_SIZE);
179         }
180
181         ret = av_grow_packet(pkt, read_size);
182         if (ret < 0)
183             break;
184
185         ret = avio_read(s, pkt->data + prev_size, read_size);
186         if (ret != read_size) {
187             av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
188             break;
189         }
190
191         size -= read_size;
192     } while (size > 0);
193     if (size > 0)
194         pkt->flags |= AV_PKT_FLAG_CORRUPT;
195
196     pkt->pos = orig_pos;
197     if (!pkt->size)
198         av_free_packet(pkt);
199     return pkt->size > orig_size ? pkt->size - orig_size : ret;
200 }
201
202 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
203 {
204     av_init_packet(pkt);
205     pkt->data = NULL;
206     pkt->size = 0;
207     pkt->pos  = avio_tell(s);
208
209     return append_packet_chunked(s, pkt, size);
210 }
211
212 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
213 {
214     if (!pkt->size)
215         return av_get_packet(s, pkt, size);
216     return append_packet_chunked(s, pkt, size);
217 }
218
219
220 int av_filename_number_test(const char *filename)
221 {
222     char buf[1024];
223     return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
224 }
225
226 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
227 {
228     AVProbeData lpd = *pd;
229     AVInputFormat *fmt1 = NULL, *fmt;
230     int score, nodat = 0, score_max=0;
231     const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
232
233     if (!lpd.buf)
234         lpd.buf = zerobuffer;
235
236     if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
237         int id3len = ff_id3v2_tag_len(lpd.buf);
238         if (lpd.buf_size > id3len + 16) {
239             lpd.buf += id3len;
240             lpd.buf_size -= id3len;
241         }else
242             nodat = 1;
243     }
244
245     fmt = NULL;
246     while ((fmt1 = av_iformat_next(fmt1))) {
247         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
248             continue;
249         score = 0;
250         if (fmt1->read_probe) {
251             score = fmt1->read_probe(&lpd);
252             if(fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
253                 score = FFMAX(score, nodat ? AVPROBE_SCORE_EXTENSION / 2 - 1 : 1);
254         } else if (fmt1->extensions) {
255             if (av_match_ext(lpd.filename, fmt1->extensions)) {
256                 score = AVPROBE_SCORE_EXTENSION;
257             }
258         }
259         if (score > score_max) {
260             score_max = score;
261             fmt = fmt1;
262         }else if (score == score_max)
263             fmt = NULL;
264     }
265     if(nodat)
266         score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
267     *score_ret= score_max;
268
269     return fmt;
270 }
271
272 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
273 {
274     int score_ret;
275     AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
276     if(score_ret > *score_max){
277         *score_max= score_ret;
278         return fmt;
279     }else
280         return NULL;
281 }
282
283 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
284     int score=0;
285     return av_probe_input_format2(pd, is_opened, &score);
286 }
287
288 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
289 {
290     static const struct {
291         const char *name; enum AVCodecID id; enum AVMediaType type;
292     } fmt_id_type[] = {
293         { "aac"      , AV_CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
294         { "ac3"      , AV_CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
295         { "dts"      , AV_CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
296         { "eac3"     , AV_CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
297         { "h264"     , AV_CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
298         { "loas"     , AV_CODEC_ID_AAC_LATM  , AVMEDIA_TYPE_AUDIO },
299         { "m4v"      , AV_CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
300         { "mp3"      , AV_CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
301         { "mpegvideo", AV_CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
302         { 0 }
303     };
304     int score;
305     AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
306
307     if (fmt && st->request_probe <= score) {
308         int i;
309         av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
310                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
311         for (i = 0; fmt_id_type[i].name; i++) {
312             if (!strcmp(fmt->name, fmt_id_type[i].name)) {
313                 st->codec->codec_id   = fmt_id_type[i].id;
314                 st->codec->codec_type = fmt_id_type[i].type;
315                 break;
316             }
317         }
318     }
319     return score;
320 }
321
322 /************************************************************/
323 /* input media file */
324
325 int av_demuxer_open(AVFormatContext *ic){
326     int err;
327
328     if (ic->iformat->read_header) {
329         err = ic->iformat->read_header(ic);
330         if (err < 0)
331             return err;
332     }
333
334     if (ic->pb && !ic->data_offset)
335         ic->data_offset = avio_tell(ic->pb);
336
337     return 0;
338 }
339
340
341 int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
342                           const char *filename, void *logctx,
343                           unsigned int offset, unsigned int max_probe_size)
344 {
345     AVProbeData pd = { filename ? filename : "", NULL, -offset };
346     unsigned char *buf = NULL;
347     uint8_t *mime_type;
348     int ret = 0, probe_size, buf_offset = 0;
349     int score = 0;
350
351     if (!max_probe_size) {
352         max_probe_size = PROBE_BUF_MAX;
353     } else if (max_probe_size > PROBE_BUF_MAX) {
354         max_probe_size = PROBE_BUF_MAX;
355     } else if (max_probe_size < PROBE_BUF_MIN) {
356         av_log(logctx, AV_LOG_ERROR,
357                "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
358         return AVERROR(EINVAL);
359     }
360
361     if (offset >= max_probe_size) {
362         return AVERROR(EINVAL);
363     }
364
365     if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
366         if (!av_strcasecmp(mime_type, "audio/aacp")) {
367             *fmt = av_find_input_format("aac");
368         }
369         av_freep(&mime_type);
370     }
371
372     for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
373         probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
374
375         if (probe_size < offset) {
376             continue;
377         }
378         score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
379
380         /* read probe data */
381         if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
382             return ret;
383         if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
384             /* fail if error was not end of file, otherwise, lower score */
385             if (ret != AVERROR_EOF) {
386                 av_free(buf);
387                 return ret;
388             }
389             score = 0;
390             ret = 0;            /* error was end of file, nothing read */
391         }
392         pd.buf_size = buf_offset += ret;
393         pd.buf = &buf[offset];
394
395         memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
396
397         /* guess file format */
398         *fmt = av_probe_input_format2(&pd, 1, &score);
399         if(*fmt){
400             if(score <= AVPROBE_SCORE_RETRY){ //this can only be true in the last iteration
401                 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
402             }else
403                 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
404 #if 0
405             FILE *f = fopen("probestat.tmp", "ab");
406             fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
407             fclose(f);
408 #endif
409         }
410     }
411
412     if (!*fmt) {
413         av_free(buf);
414         return AVERROR_INVALIDDATA;
415     }
416
417     /* rewind. reuse probe buffer to avoid seeking */
418     ret = ffio_rewind_with_probe_data(pb, &buf, pd.buf_size);
419
420     return ret < 0 ? ret : score;
421 }
422
423 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
424                           const char *filename, void *logctx,
425                           unsigned int offset, unsigned int max_probe_size)
426 {
427     int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
428     return ret < 0 ? ret : 0;
429 }
430
431
432 /* open input file and probe the format if necessary */
433 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
434 {
435     int ret;
436     AVProbeData pd = {filename, NULL, 0};
437     int score = AVPROBE_SCORE_RETRY;
438
439     if (s->pb) {
440         s->flags |= AVFMT_FLAG_CUSTOM_IO;
441         if (!s->iformat)
442             return av_probe_input_buffer2(s->pb, &s->iformat, filename, s, 0, s->probesize);
443         else if (s->iformat->flags & AVFMT_NOFILE)
444             av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
445                                       "will be ignored with AVFMT_NOFILE format.\n");
446         return 0;
447     }
448
449     if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
450         (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
451         return score;
452
453     if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ | s->avio_flags,
454                           &s->interrupt_callback, options)) < 0)
455         return ret;
456     if (s->iformat)
457         return 0;
458     return av_probe_input_buffer2(s->pb, &s->iformat, filename, s, 0, s->probesize);
459 }
460
461 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
462                                AVPacketList **plast_pktl){
463     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
464     if (!pktl)
465         return NULL;
466
467     if (*packet_buffer)
468         (*plast_pktl)->next = pktl;
469     else
470         *packet_buffer = pktl;
471
472     /* add the packet in the buffered packet list */
473     *plast_pktl = pktl;
474     pktl->pkt= *pkt;
475     return &pktl->pkt;
476 }
477
478 int avformat_queue_attached_pictures(AVFormatContext *s)
479 {
480     int i;
481     for (i = 0; i < s->nb_streams; i++)
482         if (s->streams[i]->disposition & AV_DISPOSITION_ATTACHED_PIC &&
483             s->streams[i]->discard < AVDISCARD_ALL) {
484             AVPacket copy = s->streams[i]->attached_pic;
485             copy.buf      = av_buffer_ref(copy.buf);
486             if (!copy.buf)
487                 return AVERROR(ENOMEM);
488
489             add_to_pktbuf(&s->raw_packet_buffer, &copy, &s->raw_packet_buffer_end);
490         }
491     return 0;
492 }
493
494 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
495 {
496     AVFormatContext *s = *ps;
497     int ret = 0;
498     AVDictionary *tmp = NULL;
499     ID3v2ExtraMeta *id3v2_extra_meta = NULL;
500
501     if (!s && !(s = avformat_alloc_context()))
502         return AVERROR(ENOMEM);
503     if (!s->av_class){
504         av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
505         return AVERROR(EINVAL);
506     }
507     if (fmt)
508         s->iformat = fmt;
509
510     if (options)
511         av_dict_copy(&tmp, *options, 0);
512
513     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
514         goto fail;
515
516     if ((ret = init_input(s, filename, &tmp)) < 0)
517         goto fail;
518     s->probe_score = ret;
519     avio_skip(s->pb, s->skip_initial_bytes);
520
521     /* check filename in case an image number is expected */
522     if (s->iformat->flags & AVFMT_NEEDNUMBER) {
523         if (!av_filename_number_test(filename)) {
524             ret = AVERROR(EINVAL);
525             goto fail;
526         }
527     }
528
529     s->duration = s->start_time = AV_NOPTS_VALUE;
530     av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
531
532     /* allocate private data */
533     if (s->iformat->priv_data_size > 0) {
534         if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
535             ret = AVERROR(ENOMEM);
536             goto fail;
537         }
538         if (s->iformat->priv_class) {
539             *(const AVClass**)s->priv_data = s->iformat->priv_class;
540             av_opt_set_defaults(s->priv_data);
541             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
542                 goto fail;
543         }
544     }
545
546     /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
547     if (s->pb)
548         ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
549
550     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
551         if ((ret = s->iformat->read_header(s)) < 0)
552             goto fail;
553
554     if (id3v2_extra_meta) {
555         if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
556             !strcmp(s->iformat->name, "tta")) {
557             if((ret = ff_id3v2_parse_apic(s, &id3v2_extra_meta)) < 0)
558                 goto fail;
559         } else
560             av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
561     }
562     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
563
564     if ((ret = avformat_queue_attached_pictures(s)) < 0)
565         goto fail;
566
567     if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
568         s->data_offset = avio_tell(s->pb);
569
570     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
571
572     if (options) {
573         av_dict_free(options);
574         *options = tmp;
575     }
576     *ps = s;
577     return 0;
578
579 fail:
580     ff_id3v2_free_extra_meta(&id3v2_extra_meta);
581     av_dict_free(&tmp);
582     if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
583         avio_close(s->pb);
584     avformat_free_context(s);
585     *ps = NULL;
586     return ret;
587 }
588
589 /*******************************************************/
590
591 static void force_codec_ids(AVFormatContext *s, AVStream *st)
592 {
593     switch(st->codec->codec_type){
594     case AVMEDIA_TYPE_VIDEO:
595         if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
596         break;
597     case AVMEDIA_TYPE_AUDIO:
598         if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
599         break;
600     case AVMEDIA_TYPE_SUBTITLE:
601         if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
602         break;
603     }
604 }
605
606 static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
607 {
608     if(st->request_probe>0){
609         AVProbeData *pd = &st->probe_data;
610         int end;
611         av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
612         --st->probe_packets;
613
614         if (pkt) {
615             uint8_t *new_buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
616             if(!new_buf) {
617                 av_log(s, AV_LOG_WARNING,
618                        "Failed to reallocate probe buffer for stream %d\n",
619                        st->index);
620                 goto no_packet;
621             }
622             pd->buf = new_buf;
623             memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
624             pd->buf_size += pkt->size;
625             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
626         } else {
627 no_packet:
628             st->probe_packets = 0;
629             if (!pd->buf_size) {
630                 av_log(s, AV_LOG_WARNING, "nothing to probe for stream %d\n",
631                        st->index);
632             }
633         }
634
635         end=    s->raw_packet_buffer_remaining_size <= 0
636                 || st->probe_packets<=0;
637
638         if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
639             int score= set_codec_from_probe_data(s, st, pd);
640             if(    (st->codec->codec_id != AV_CODEC_ID_NONE && score > AVPROBE_SCORE_RETRY)
641                 || end){
642                 pd->buf_size=0;
643                 av_freep(&pd->buf);
644                 st->request_probe= -1;
645                 if(st->codec->codec_id != AV_CODEC_ID_NONE){
646                     av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
647                 }else
648                     av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
649             }
650             force_codec_ids(s, st);
651         }
652     }
653     return 0;
654 }
655
656 static int update_wrap_reference(AVFormatContext *s, AVStream *st, int stream_index, AVPacket *pkt)
657 {
658     int64_t ref = pkt->dts;
659     int i, pts_wrap_behavior;
660     int64_t pts_wrap_reference;
661     AVProgram *first_program;
662
663     if (ref == AV_NOPTS_VALUE)
664         ref = pkt->pts;
665     if (st->pts_wrap_reference != AV_NOPTS_VALUE || st->pts_wrap_bits >= 63 || ref == AV_NOPTS_VALUE || !s->correct_ts_overflow)
666         return 0;
667     ref &= (1LL<<st->pts_wrap_bits)-1;
668
669     // reference time stamp should be 60 s before first time stamp
670     pts_wrap_reference = ref - av_rescale(60, st->time_base.den, st->time_base.num);
671     // if first time stamp is not more than 1/8 and 60s before the wrap point, subtract rather than add wrap offset
672     pts_wrap_behavior = (ref < (1LL<<st->pts_wrap_bits) - (1LL<<st->pts_wrap_bits-3)) ||
673         (ref < (1LL<<st->pts_wrap_bits) - av_rescale(60, st->time_base.den, st->time_base.num)) ?
674         AV_PTS_WRAP_ADD_OFFSET : AV_PTS_WRAP_SUB_OFFSET;
675
676     first_program = av_find_program_from_stream(s, NULL, stream_index);
677
678     if (!first_program) {
679         int default_stream_index = av_find_default_stream_index(s);
680         if (s->streams[default_stream_index]->pts_wrap_reference == AV_NOPTS_VALUE) {
681             for (i=0; i<s->nb_streams; i++) {
682                 s->streams[i]->pts_wrap_reference = pts_wrap_reference;
683                 s->streams[i]->pts_wrap_behavior = pts_wrap_behavior;
684             }
685         }
686         else {
687             st->pts_wrap_reference = s->streams[default_stream_index]->pts_wrap_reference;
688             st->pts_wrap_behavior = s->streams[default_stream_index]->pts_wrap_behavior;
689         }
690     }
691     else {
692         AVProgram *program = first_program;
693         while (program) {
694             if (program->pts_wrap_reference != AV_NOPTS_VALUE) {
695                 pts_wrap_reference = program->pts_wrap_reference;
696                 pts_wrap_behavior = program->pts_wrap_behavior;
697                 break;
698             }
699             program = av_find_program_from_stream(s, program, stream_index);
700         }
701
702         // update every program with differing pts_wrap_reference
703         program = first_program;
704         while(program) {
705             if (program->pts_wrap_reference != pts_wrap_reference) {
706                 for (i=0; i<program->nb_stream_indexes; i++) {
707                     s->streams[program->stream_index[i]]->pts_wrap_reference = pts_wrap_reference;
708                     s->streams[program->stream_index[i]]->pts_wrap_behavior = pts_wrap_behavior;
709                 }
710
711                 program->pts_wrap_reference = pts_wrap_reference;
712                 program->pts_wrap_behavior = pts_wrap_behavior;
713             }
714             program = av_find_program_from_stream(s, program, stream_index);
715         }
716     }
717     return 1;
718 }
719
720 int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
721 {
722     int ret, i, err;
723     AVStream *st;
724
725     for(;;){
726         AVPacketList *pktl = s->raw_packet_buffer;
727
728         if (pktl) {
729             *pkt = pktl->pkt;
730             st = s->streams[pkt->stream_index];
731             if (s->raw_packet_buffer_remaining_size <= 0) {
732                 if ((err = probe_codec(s, st, NULL)) < 0)
733                     return err;
734             }
735             if(st->request_probe <= 0){
736                 s->raw_packet_buffer = pktl->next;
737                 s->raw_packet_buffer_remaining_size += pkt->size;
738                 av_free(pktl);
739                 return 0;
740             }
741         }
742
743         pkt->data = NULL;
744         pkt->size = 0;
745         av_init_packet(pkt);
746         ret= s->iformat->read_packet(s, pkt);
747         if (ret < 0) {
748             if (!pktl || ret == AVERROR(EAGAIN))
749                 return ret;
750             for (i = 0; i < s->nb_streams; i++) {
751                 st = s->streams[i];
752                 if (st->probe_packets) {
753                     if ((err = probe_codec(s, st, NULL)) < 0)
754                         return err;
755                 }
756                 av_assert0(st->request_probe <= 0);
757             }
758             continue;
759         }
760
761         if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
762             (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
763             av_log(s, AV_LOG_WARNING,
764                    "Dropped corrupted packet (stream = %d)\n",
765                    pkt->stream_index);
766             av_free_packet(pkt);
767             continue;
768         }
769
770         if(pkt->stream_index >= (unsigned)s->nb_streams){
771             av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
772             continue;
773         }
774
775         st= s->streams[pkt->stream_index];
776
777         if (update_wrap_reference(s, st, pkt->stream_index, pkt) && st->pts_wrap_behavior == AV_PTS_WRAP_SUB_OFFSET) {
778             // correct first time stamps to negative values
779             if (!is_relative(st->first_dts))
780                 st->first_dts = wrap_timestamp(st, st->first_dts);
781             if (!is_relative(st->start_time))
782                 st->start_time = wrap_timestamp(st, st->start_time);
783             if (!is_relative(st->cur_dts))
784                 st->cur_dts = wrap_timestamp(st, st->cur_dts);
785         }
786
787         pkt->dts = wrap_timestamp(st, pkt->dts);
788         pkt->pts = wrap_timestamp(st, pkt->pts);
789
790         force_codec_ids(s, st);
791
792         /* TODO: audio: time filter; video: frame reordering (pts != dts) */
793         if (s->use_wallclock_as_timestamps)
794             pkt->dts = pkt->pts = av_rescale_q(av_gettime(), AV_TIME_BASE_Q, st->time_base);
795
796         if(!pktl && st->request_probe <= 0)
797             return ret;
798
799         add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
800         s->raw_packet_buffer_remaining_size -= pkt->size;
801
802         if ((err = probe_codec(s, st, pkt)) < 0)
803             return err;
804     }
805 }
806
807 #if FF_API_READ_PACKET
808 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
809 {
810     return ff_read_packet(s, pkt);
811 }
812 #endif
813
814
815 /**********************************************************/
816
817 static int determinable_frame_size(AVCodecContext *avctx)
818 {
819     if (/*avctx->codec_id == AV_CODEC_ID_AAC ||*/
820         avctx->codec_id == AV_CODEC_ID_MP1 ||
821         avctx->codec_id == AV_CODEC_ID_MP2 ||
822         avctx->codec_id == AV_CODEC_ID_MP3/* ||
823         avctx->codec_id == AV_CODEC_ID_CELT*/)
824         return 1;
825     return 0;
826 }
827
828 /**
829  * Get the number of samples of an audio frame. Return -1 on error.
830  */
831 int ff_get_audio_frame_size(AVCodecContext *enc, int size, int mux)
832 {
833     int frame_size;
834
835     /* give frame_size priority if demuxing */
836     if (!mux && enc->frame_size > 1)
837         return enc->frame_size;
838
839     if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
840         return frame_size;
841
842     /* Fall back on using frame_size if muxing. */
843     if (enc->frame_size > 1)
844         return enc->frame_size;
845
846     //For WMA we currently have no other means to calculate duration thus we
847     //do it here by assuming CBR, which is true for all known cases.
848     if(!mux && enc->bit_rate>0 && size>0 && enc->sample_rate>0 && enc->block_align>1) {
849         if (enc->codec_id == AV_CODEC_ID_WMAV1 || enc->codec_id == AV_CODEC_ID_WMAV2)
850             return  ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
851     }
852
853     return -1;
854 }
855
856
857 /**
858  * Return the frame duration in seconds. Return 0 if not available.
859  */
860 void ff_compute_frame_duration(int *pnum, int *pden, AVStream *st,
861                                AVCodecParserContext *pc, AVPacket *pkt)
862 {
863     int frame_size;
864
865     *pnum = 0;
866     *pden = 0;
867     switch(st->codec->codec_type) {
868     case AVMEDIA_TYPE_VIDEO:
869         if (st->r_frame_rate.num && !pc) {
870             *pnum = st->r_frame_rate.den;
871             *pden = st->r_frame_rate.num;
872         } else if(st->time_base.num*1000LL > st->time_base.den) {
873             *pnum = st->time_base.num;
874             *pden = st->time_base.den;
875         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
876             *pnum = st->codec->time_base.num;
877             *pden = st->codec->time_base.den;
878             if (pc && pc->repeat_pict) {
879                 if (*pnum > INT_MAX / (1 + pc->repeat_pict))
880                     *pden /= 1 + pc->repeat_pict;
881                 else
882                     *pnum *= 1 + pc->repeat_pict;
883             }
884             //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
885             //Thus if we have no parser in such case leave duration undefined.
886             if(st->codec->ticks_per_frame>1 && !pc){
887                 *pnum = *pden = 0;
888             }
889         }
890         break;
891     case AVMEDIA_TYPE_AUDIO:
892         frame_size = ff_get_audio_frame_size(st->codec, pkt->size, 0);
893         if (frame_size <= 0 || st->codec->sample_rate <= 0)
894             break;
895         *pnum = frame_size;
896         *pden = st->codec->sample_rate;
897         break;
898     default:
899         break;
900     }
901 }
902
903 static int is_intra_only(AVCodecContext *enc){
904     const AVCodecDescriptor *desc;
905
906     if(enc->codec_type != AVMEDIA_TYPE_VIDEO)
907         return 1;
908
909     desc = av_codec_get_codec_descriptor(enc);
910     if (!desc) {
911         desc = avcodec_descriptor_get(enc->codec_id);
912         av_codec_set_codec_descriptor(enc, desc);
913     }
914     if (desc)
915         return !!(desc->props & AV_CODEC_PROP_INTRA_ONLY);
916     return 0;
917 }
918
919 static int has_decode_delay_been_guessed(AVStream *st)
920 {
921     if(st->codec->codec_id != AV_CODEC_ID_H264) return 1;
922     if(!st->info) // if we have left find_stream_info then nb_decoded_frames won't increase anymore for stream copy
923         return 1;
924 #if CONFIG_H264_DECODER
925     if(st->codec->has_b_frames &&
926        avpriv_h264_has_num_reorder_frames(st->codec) == st->codec->has_b_frames)
927         return 1;
928 #endif
929     if(st->codec->has_b_frames<3)
930         return st->nb_decoded_frames >= 7;
931     else if(st->codec->has_b_frames<4)
932         return st->nb_decoded_frames >= 18;
933     else
934         return st->nb_decoded_frames >= 20;
935 }
936
937 static AVPacketList *get_next_pkt(AVFormatContext *s, AVStream *st, AVPacketList *pktl)
938 {
939     if (pktl->next)
940         return pktl->next;
941     if (pktl == s->parse_queue_end)
942         return s->packet_buffer;
943     return NULL;
944 }
945
946 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
947                                       int64_t dts, int64_t pts, AVPacket *pkt)
948 {
949     AVStream *st= s->streams[stream_index];
950     AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
951     int64_t pts_buffer[MAX_REORDER_DELAY+1];
952     int64_t shift;
953     int i, delay;
954
955     if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE || is_relative(dts))
956         return;
957
958     delay = st->codec->has_b_frames;
959     st->first_dts= dts - (st->cur_dts - RELATIVE_TS_BASE);
960     st->cur_dts= dts;
961     shift = st->first_dts - RELATIVE_TS_BASE;
962
963     for (i=0; i<MAX_REORDER_DELAY+1; i++)
964         pts_buffer[i] = AV_NOPTS_VALUE;
965
966     if (is_relative(pts))
967         pts += shift;
968
969     for(; pktl; pktl= get_next_pkt(s, st, pktl)){
970         if(pktl->pkt.stream_index != stream_index)
971             continue;
972         if(is_relative(pktl->pkt.pts))
973             pktl->pkt.pts += shift;
974
975         if(is_relative(pktl->pkt.dts))
976             pktl->pkt.dts += shift;
977
978         if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
979             st->start_time= pktl->pkt.pts;
980
981         if(pktl->pkt.pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
982             pts_buffer[0]= pktl->pkt.pts;
983             for(i=0; i<delay && pts_buffer[i] > pts_buffer[i+1]; i++)
984                 FFSWAP(int64_t, pts_buffer[i], pts_buffer[i+1]);
985             if(pktl->pkt.dts == AV_NOPTS_VALUE)
986                 pktl->pkt.dts= pts_buffer[0];
987         }
988     }
989
990     if (st->start_time == AV_NOPTS_VALUE)
991         st->start_time = pts;
992 }
993
994 static void update_initial_durations(AVFormatContext *s, AVStream *st,
995                                      int stream_index, int duration)
996 {
997     AVPacketList *pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
998     int64_t cur_dts= RELATIVE_TS_BASE;
999
1000     if(st->first_dts != AV_NOPTS_VALUE){
1001         cur_dts= st->first_dts;
1002         for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1003             if(pktl->pkt.stream_index == stream_index){
1004                 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
1005                     break;
1006                 cur_dts -= duration;
1007             }
1008         }
1009         if(pktl && pktl->pkt.dts != st->first_dts) {
1010             av_log(s, AV_LOG_DEBUG, "first_dts %s not matching first dts %s (pts %s, duration %d) in the queue\n",
1011                    av_ts2str(st->first_dts), av_ts2str(pktl->pkt.dts), av_ts2str(pktl->pkt.pts), pktl->pkt.duration);
1012             return;
1013         }
1014         if(!pktl) {
1015             av_log(s, AV_LOG_DEBUG, "first_dts %s but no packet with dts in the queue\n", av_ts2str(st->first_dts));
1016             return;
1017         }
1018         pktl= s->parse_queue ? s->parse_queue : s->packet_buffer;
1019         st->first_dts = cur_dts;
1020     }else if(st->cur_dts != RELATIVE_TS_BASE)
1021         return;
1022
1023     for(; pktl; pktl= get_next_pkt(s, st, pktl)){
1024         if(pktl->pkt.stream_index != stream_index)
1025             continue;
1026         if(pktl->pkt.pts == pktl->pkt.dts && (pktl->pkt.dts == AV_NOPTS_VALUE || pktl->pkt.dts == st->first_dts)
1027            && !pktl->pkt.duration){
1028             pktl->pkt.dts= cur_dts;
1029             if(!st->codec->has_b_frames)
1030                 pktl->pkt.pts= cur_dts;
1031 //            if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
1032                 pktl->pkt.duration = duration;
1033         }else
1034             break;
1035         cur_dts = pktl->pkt.dts + pktl->pkt.duration;
1036     }
1037     if(!pktl)
1038         st->cur_dts= cur_dts;
1039 }
1040
1041 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
1042                                AVCodecParserContext *pc, AVPacket *pkt)
1043 {
1044     int num, den, presentation_delayed, delay, i;
1045     int64_t offset;
1046
1047     if (s->flags & AVFMT_FLAG_NOFILLIN)
1048         return;
1049
1050     if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1051         pkt->dts= AV_NOPTS_VALUE;
1052
1053     if (pc && pc->pict_type == AV_PICTURE_TYPE_B
1054         && !st->codec->has_b_frames)
1055         //FIXME Set low_delay = 0 when has_b_frames = 1
1056         st->codec->has_b_frames = 1;
1057
1058     /* do we have a video B-frame ? */
1059     delay= st->codec->has_b_frames;
1060     presentation_delayed = 0;
1061
1062     /* XXX: need has_b_frame, but cannot get it if the codec is
1063         not initialized */
1064     if (delay &&
1065         pc && pc->pict_type != AV_PICTURE_TYPE_B)
1066         presentation_delayed = 1;
1067
1068     if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
1069         st->pts_wrap_bits < 63 &&
1070         pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
1071         if(is_relative(st->cur_dts) || pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > st->cur_dts) {
1072             pkt->dts -= 1LL<<st->pts_wrap_bits;
1073         } else
1074             pkt->pts += 1LL<<st->pts_wrap_bits;
1075     }
1076
1077     // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
1078     // we take the conservative approach and discard both
1079     // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
1080     if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
1081         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1082         if(strcmp(s->iformat->name, "mov,mp4,m4a,3gp,3g2,mj2")) // otherwise we discard correct timestamps for vc1-wmapro.ism
1083             pkt->dts= AV_NOPTS_VALUE;
1084     }
1085
1086     if (pkt->duration == 0) {
1087         ff_compute_frame_duration(&num, &den, st, pc, pkt);
1088         if (den && num) {
1089             pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1090         }
1091     }
1092     if(pkt->duration != 0 && (s->packet_buffer || s->parse_queue))
1093         update_initial_durations(s, st, pkt->stream_index, pkt->duration);
1094
1095     /* correct timestamps with byte offset if demuxers only have timestamps
1096        on packet boundaries */
1097     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1098         /* this will estimate bitrate based on this frame's duration and size */
1099         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1100         if(pkt->pts != AV_NOPTS_VALUE)
1101             pkt->pts += offset;
1102         if(pkt->dts != AV_NOPTS_VALUE)
1103             pkt->dts += offset;
1104     }
1105
1106     /* This may be redundant, but it should not hurt. */
1107     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1108         presentation_delayed = 1;
1109
1110     av_dlog(NULL, "IN delayed:%d pts:%s, dts:%s cur_dts:%s st:%d pc:%p duration:%d\n",
1111            presentation_delayed, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts), pkt->stream_index, pc, pkt->duration);
1112     /* interpolate PTS and DTS if they are not present */
1113     //We skip H264 currently because delay and has_b_frames are not reliably set
1114     if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != AV_CODEC_ID_H264){
1115         if (presentation_delayed) {
1116             /* DTS = decompression timestamp */
1117             /* PTS = presentation timestamp */
1118             if (pkt->dts == AV_NOPTS_VALUE)
1119                 pkt->dts = st->last_IP_pts;
1120             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt);
1121             if (pkt->dts == AV_NOPTS_VALUE)
1122                 pkt->dts = st->cur_dts;
1123
1124             /* this is tricky: the dts must be incremented by the duration
1125             of the frame we are displaying, i.e. the last I- or P-frame */
1126             if (st->last_IP_duration == 0)
1127                 st->last_IP_duration = pkt->duration;
1128             if(pkt->dts != AV_NOPTS_VALUE)
1129                 st->cur_dts = pkt->dts + st->last_IP_duration;
1130             st->last_IP_duration  = pkt->duration;
1131             st->last_IP_pts= pkt->pts;
1132             /* cannot compute PTS if not present (we can compute it only
1133             by knowing the future */
1134         } else if (pkt->pts != AV_NOPTS_VALUE ||
1135                    pkt->dts != AV_NOPTS_VALUE ||
1136                    pkt->duration                ) {
1137             int duration = pkt->duration;
1138
1139             /* presentation is not delayed : PTS and DTS are the same */
1140             if (pkt->pts == AV_NOPTS_VALUE)
1141                 pkt->pts = pkt->dts;
1142             update_initial_timestamps(s, pkt->stream_index, pkt->pts,
1143                                       pkt->pts, pkt);
1144             if (pkt->pts == AV_NOPTS_VALUE)
1145                 pkt->pts = st->cur_dts;
1146             pkt->dts = pkt->pts;
1147             if (pkt->pts != AV_NOPTS_VALUE)
1148                 st->cur_dts = pkt->pts + duration;
1149         }
1150     }
1151
1152     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY && has_decode_delay_been_guessed(st)){
1153         st->pts_buffer[0]= pkt->pts;
1154         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1155             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1156         if(pkt->dts == AV_NOPTS_VALUE)
1157             pkt->dts= st->pts_buffer[0];
1158     }
1159     if(st->codec->codec_id == AV_CODEC_ID_H264){ // we skipped it above so we try here
1160         update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts, pkt); // this should happen on the first packet
1161     }
1162     if(pkt->dts > st->cur_dts)
1163         st->cur_dts = pkt->dts;
1164
1165     av_dlog(NULL, "OUTdelayed:%d/%d pts:%s, dts:%s cur_dts:%s\n",
1166             presentation_delayed, delay, av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->cur_dts));
1167
1168     /* update flags */
1169     if (is_intra_only(st->codec))
1170         pkt->flags |= AV_PKT_FLAG_KEY;
1171     if (pc)
1172         pkt->convergence_duration = pc->convergence_duration;
1173 }
1174
1175 static void free_packet_buffer(AVPacketList **pkt_buf, AVPacketList **pkt_buf_end)
1176 {
1177     while (*pkt_buf) {
1178         AVPacketList *pktl = *pkt_buf;
1179         *pkt_buf = pktl->next;
1180         av_free_packet(&pktl->pkt);
1181         av_freep(&pktl);
1182     }
1183     *pkt_buf_end = NULL;
1184 }
1185
1186 /**
1187  * Parse a packet, add all split parts to parse_queue
1188  *
1189  * @param pkt packet to parse, NULL when flushing the parser at end of stream
1190  */
1191 static int parse_packet(AVFormatContext *s, AVPacket *pkt, int stream_index)
1192 {
1193     AVPacket out_pkt = { 0 }, flush_pkt = { 0 };
1194     AVStream     *st = s->streams[stream_index];
1195     uint8_t    *data = pkt ? pkt->data : NULL;
1196     int         size = pkt ? pkt->size : 0;
1197     int ret = 0, got_output = 0;
1198
1199     if (!pkt) {
1200         av_init_packet(&flush_pkt);
1201         pkt = &flush_pkt;
1202         got_output = 1;
1203     } else if (!size && st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) {
1204         // preserve 0-size sync packets
1205         compute_pkt_fields(s, st, st->parser, pkt);
1206     }
1207
1208     while (size > 0 || (pkt == &flush_pkt && got_output)) {
1209         int len;
1210
1211         av_init_packet(&out_pkt);
1212         len = av_parser_parse2(st->parser,  st->codec,
1213                                &out_pkt.data, &out_pkt.size, data, size,
1214                                pkt->pts, pkt->dts, pkt->pos);
1215
1216         pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1217         pkt->pos = -1;
1218         /* increment read pointer */
1219         data += len;
1220         size -= len;
1221
1222         got_output = !!out_pkt.size;
1223
1224         if (!out_pkt.size)
1225             continue;
1226
1227         if (pkt->side_data) {
1228             out_pkt.side_data       = pkt->side_data;
1229             out_pkt.side_data_elems = pkt->side_data_elems;
1230             pkt->side_data       = NULL;
1231             pkt->side_data_elems = 0;
1232         }
1233
1234         /* set the duration */
1235         out_pkt.duration = 0;
1236         if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1237             if (st->codec->sample_rate > 0) {
1238                 out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1239                                                     (AVRational){ 1, st->codec->sample_rate },
1240                                                     st->time_base,
1241                                                     AV_ROUND_DOWN);
1242             }
1243         } else if (st->codec->time_base.num != 0 &&
1244                    st->codec->time_base.den != 0) {
1245             out_pkt.duration = av_rescale_q_rnd(st->parser->duration,
1246                                                 st->codec->time_base,
1247                                                 st->time_base,
1248                                                 AV_ROUND_DOWN);
1249         }
1250
1251         out_pkt.stream_index = st->index;
1252         out_pkt.pts = st->parser->pts;
1253         out_pkt.dts = st->parser->dts;
1254         out_pkt.pos = st->parser->pos;
1255
1256         if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW)
1257             out_pkt.pos = st->parser->frame_offset;
1258
1259         if (st->parser->key_frame == 1 ||
1260             (st->parser->key_frame == -1 &&
1261              st->parser->pict_type == AV_PICTURE_TYPE_I))
1262             out_pkt.flags |= AV_PKT_FLAG_KEY;
1263
1264         if(st->parser->key_frame == -1 && st->parser->pict_type==AV_PICTURE_TYPE_NONE && (pkt->flags&AV_PKT_FLAG_KEY))
1265             out_pkt.flags |= AV_PKT_FLAG_KEY;
1266
1267         compute_pkt_fields(s, st, st->parser, &out_pkt);
1268
1269         if (out_pkt.data == pkt->data && out_pkt.size == pkt->size) {
1270             out_pkt.buf   = pkt->buf;
1271             pkt->buf      = NULL;
1272 #if FF_API_DESTRUCT_PACKET
1273 FF_DISABLE_DEPRECATION_WARNINGS
1274             out_pkt.destruct = pkt->destruct;
1275             pkt->destruct = NULL;
1276 FF_ENABLE_DEPRECATION_WARNINGS
1277 #endif
1278         }
1279         if ((ret = av_dup_packet(&out_pkt)) < 0)
1280             goto fail;
1281
1282         if (!add_to_pktbuf(&s->parse_queue, &out_pkt, &s->parse_queue_end)) {
1283             av_free_packet(&out_pkt);
1284             ret = AVERROR(ENOMEM);
1285             goto fail;
1286         }
1287     }
1288
1289
1290     /* end of the stream => close and free the parser */
1291     if (pkt == &flush_pkt) {
1292         av_parser_close(st->parser);
1293         st->parser = NULL;
1294     }
1295
1296 fail:
1297     av_free_packet(pkt);
1298     return ret;
1299 }
1300
1301 static int read_from_packet_buffer(AVPacketList **pkt_buffer,
1302                                    AVPacketList **pkt_buffer_end,
1303                                    AVPacket      *pkt)
1304 {
1305     AVPacketList *pktl;
1306     av_assert0(*pkt_buffer);
1307     pktl = *pkt_buffer;
1308     *pkt = pktl->pkt;
1309     *pkt_buffer = pktl->next;
1310     if (!pktl->next)
1311         *pkt_buffer_end = NULL;
1312     av_freep(&pktl);
1313     return 0;
1314 }
1315
1316 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1317 {
1318     int ret = 0, i, got_packet = 0;
1319
1320     av_init_packet(pkt);
1321
1322     while (!got_packet && !s->parse_queue) {
1323         AVStream *st;
1324         AVPacket cur_pkt;
1325
1326         /* read next packet */
1327         ret = ff_read_packet(s, &cur_pkt);
1328         if (ret < 0) {
1329             if (ret == AVERROR(EAGAIN))
1330                 return ret;
1331             /* flush the parsers */
1332             for(i = 0; i < s->nb_streams; i++) {
1333                 st = s->streams[i];
1334                 if (st->parser && st->need_parsing)
1335                     parse_packet(s, NULL, st->index);
1336             }
1337             /* all remaining packets are now in parse_queue =>
1338              * really terminate parsing */
1339             break;
1340         }
1341         ret = 0;
1342         st  = s->streams[cur_pkt.stream_index];
1343
1344         if (cur_pkt.pts != AV_NOPTS_VALUE &&
1345             cur_pkt.dts != AV_NOPTS_VALUE &&
1346             cur_pkt.pts < cur_pkt.dts) {
1347             av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%s, dts=%s, size=%d\n",
1348                    cur_pkt.stream_index,
1349                    av_ts2str(cur_pkt.pts),
1350                    av_ts2str(cur_pkt.dts),
1351                    cur_pkt.size);
1352         }
1353         if (s->debug & FF_FDEBUG_TS)
1354             av_log(s, AV_LOG_DEBUG, "ff_read_packet stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1355                    cur_pkt.stream_index,
1356                    av_ts2str(cur_pkt.pts),
1357                    av_ts2str(cur_pkt.dts),
1358                    cur_pkt.size,
1359                    cur_pkt.duration,
1360                    cur_pkt.flags);
1361
1362         if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1363             st->parser = av_parser_init(st->codec->codec_id);
1364             if (!st->parser) {
1365                 av_log(s, AV_LOG_VERBOSE, "parser not found for codec "
1366                        "%s, packets or times may be invalid.\n",
1367                        avcodec_get_name(st->codec->codec_id));
1368                 /* no parser available: just output the raw packets */
1369                 st->need_parsing = AVSTREAM_PARSE_NONE;
1370             } else if(st->need_parsing == AVSTREAM_PARSE_HEADERS) {
1371                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1372             } else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE) {
1373                 st->parser->flags |= PARSER_FLAG_ONCE;
1374             } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
1375                 st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
1376             }
1377         }
1378
1379         if (!st->need_parsing || !st->parser) {
1380             /* no parsing needed: we just output the packet as is */
1381             *pkt = cur_pkt;
1382             compute_pkt_fields(s, st, NULL, pkt);
1383             if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1384                 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1385                 ff_reduce_index(s, st->index);
1386                 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1387             }
1388             got_packet = 1;
1389         } else if (st->discard < AVDISCARD_ALL) {
1390             if ((ret = parse_packet(s, &cur_pkt, cur_pkt.stream_index)) < 0)
1391                 return ret;
1392         } else {
1393             /* free packet */
1394             av_free_packet(&cur_pkt);
1395         }
1396         if (pkt->flags & AV_PKT_FLAG_KEY)
1397             st->skip_to_keyframe = 0;
1398         if (st->skip_to_keyframe) {
1399             av_free_packet(&cur_pkt);
1400             if (got_packet) {
1401                 *pkt = cur_pkt;
1402             }
1403             got_packet = 0;
1404         }
1405     }
1406
1407     if (!got_packet && s->parse_queue)
1408         ret = read_from_packet_buffer(&s->parse_queue, &s->parse_queue_end, pkt);
1409
1410     if (ret >= 0) {
1411         AVStream *st = s->streams[pkt->stream_index];
1412         if (st->skip_samples) {
1413             uint8_t *p = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10);
1414             if (p) {
1415                 AV_WL32(p, st->skip_samples);
1416                 av_log(s, AV_LOG_DEBUG, "demuxer injecting skip %d\n", st->skip_samples);
1417             }
1418             st->skip_samples = 0;
1419         }
1420     }
1421
1422     if(ret >= 0 && !(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
1423         av_packet_merge_side_data(pkt);
1424
1425     if(s->debug & FF_FDEBUG_TS)
1426         av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%s, dts=%s, size=%d, duration=%d, flags=%d\n",
1427             pkt->stream_index,
1428             av_ts2str(pkt->pts),
1429             av_ts2str(pkt->dts),
1430             pkt->size,
1431             pkt->duration,
1432             pkt->flags);
1433
1434     return ret;
1435 }
1436
1437 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1438 {
1439     const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1440     int          eof = 0;
1441     int ret;
1442     AVStream *st;
1443
1444     if (!genpts) {
1445         ret = s->packet_buffer ?
1446             read_from_packet_buffer(&s->packet_buffer, &s->packet_buffer_end, pkt) :
1447             read_frame_internal(s, pkt);
1448         if (ret < 0)
1449             return ret;
1450         goto return_packet;
1451     }
1452
1453     for (;;) {
1454         AVPacketList *pktl = s->packet_buffer;
1455
1456         if (pktl) {
1457             AVPacket *next_pkt = &pktl->pkt;
1458
1459             if (next_pkt->dts != AV_NOPTS_VALUE) {
1460                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1461                 // last dts seen for this stream. if any of packets following
1462                 // current one had no dts, we will set this to AV_NOPTS_VALUE.
1463                 int64_t last_dts = next_pkt->dts;
1464                 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1465                     if (pktl->pkt.stream_index == next_pkt->stream_index &&
1466                         (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0)) {
1467                         if (av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1468                             next_pkt->pts = pktl->pkt.dts;
1469                         }
1470                         if (last_dts != AV_NOPTS_VALUE) {
1471                             // Once last dts was set to AV_NOPTS_VALUE, we don't change it.
1472                             last_dts = pktl->pkt.dts;
1473                         }
1474                     }
1475                     pktl = pktl->next;
1476                 }
1477                 if (eof && next_pkt->pts == AV_NOPTS_VALUE && last_dts != AV_NOPTS_VALUE) {
1478                     // Fixing the last reference frame had none pts issue (For MXF etc).
1479                     // We only do this when
1480                     // 1. eof.
1481                     // 2. we are not able to resolve a pts value for current packet.
1482                     // 3. the packets for this stream at the end of the files had valid dts.
1483                     next_pkt->pts = last_dts + next_pkt->duration;
1484                 }
1485                 pktl = s->packet_buffer;
1486             }
1487
1488             /* read packet from packet buffer, if there is data */
1489             if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1490                   next_pkt->dts != AV_NOPTS_VALUE && !eof)) {
1491                 ret = read_from_packet_buffer(&s->packet_buffer,
1492                                                &s->packet_buffer_end, pkt);
1493                 goto return_packet;
1494             }
1495         }
1496
1497         ret = read_frame_internal(s, pkt);
1498         if (ret < 0) {
1499             if (pktl && ret != AVERROR(EAGAIN)) {
1500                 eof = 1;
1501                 continue;
1502             } else
1503                 return ret;
1504         }
1505
1506         if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1507                           &s->packet_buffer_end)) < 0)
1508             return AVERROR(ENOMEM);
1509     }
1510
1511 return_packet:
1512
1513     st = s->streams[pkt->stream_index];
1514     if ((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY) {
1515         ff_reduce_index(s, st->index);
1516         av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1517     }
1518
1519     if (is_relative(pkt->dts))
1520         pkt->dts -= RELATIVE_TS_BASE;
1521     if (is_relative(pkt->pts))
1522         pkt->pts -= RELATIVE_TS_BASE;
1523
1524     return ret;
1525 }
1526
1527 /* XXX: suppress the packet queue */
1528 static void flush_packet_queue(AVFormatContext *s)
1529 {
1530     free_packet_buffer(&s->parse_queue,       &s->parse_queue_end);
1531     free_packet_buffer(&s->packet_buffer,     &s->packet_buffer_end);
1532     free_packet_buffer(&s->raw_packet_buffer, &s->raw_packet_buffer_end);
1533
1534     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1535 }
1536
1537 /*******************************************************/
1538 /* seek support */
1539
1540 int av_find_default_stream_index(AVFormatContext *s)
1541 {
1542     int first_audio_index = -1;
1543     int i;
1544     AVStream *st;
1545
1546     if (s->nb_streams <= 0)
1547         return -1;
1548     for(i = 0; i < s->nb_streams; i++) {
1549         st = s->streams[i];
1550         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1551             !(st->disposition & AV_DISPOSITION_ATTACHED_PIC)) {
1552             return i;
1553         }
1554         if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1555             first_audio_index = i;
1556     }
1557     return first_audio_index >= 0 ? first_audio_index : 0;
1558 }
1559
1560 /**
1561  * Flush the frame reader.
1562  */
1563 void ff_read_frame_flush(AVFormatContext *s)
1564 {
1565     AVStream *st;
1566     int i, j;
1567
1568     flush_packet_queue(s);
1569
1570     /* for each stream, reset read state */
1571     for(i = 0; i < s->nb_streams; i++) {
1572         st = s->streams[i];
1573
1574         if (st->parser) {
1575             av_parser_close(st->parser);
1576             st->parser = NULL;
1577         }
1578         st->last_IP_pts = AV_NOPTS_VALUE;
1579         if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = RELATIVE_TS_BASE;
1580         else                                st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1581
1582         st->probe_packets = MAX_PROBE_PACKETS;
1583
1584         for(j=0; j<MAX_REORDER_DELAY+1; j++)
1585             st->pts_buffer[j]= AV_NOPTS_VALUE;
1586     }
1587 }
1588
1589 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1590 {
1591     int i;
1592
1593     for(i = 0; i < s->nb_streams; i++) {
1594         AVStream *st = s->streams[i];
1595
1596         st->cur_dts = av_rescale(timestamp,
1597                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1598                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1599     }
1600 }
1601
1602 void ff_reduce_index(AVFormatContext *s, int stream_index)
1603 {
1604     AVStream *st= s->streams[stream_index];
1605     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1606
1607     if((unsigned)st->nb_index_entries >= max_entries){
1608         int i;
1609         for(i=0; 2*i<st->nb_index_entries; i++)
1610             st->index_entries[i]= st->index_entries[2*i];
1611         st->nb_index_entries= i;
1612     }
1613 }
1614
1615 int ff_add_index_entry(AVIndexEntry **index_entries,
1616                        int *nb_index_entries,
1617                        unsigned int *index_entries_allocated_size,
1618                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1619 {
1620     AVIndexEntry *entries, *ie;
1621     int index;
1622
1623     if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1624         return -1;
1625
1626     if(timestamp == AV_NOPTS_VALUE)
1627         return AVERROR(EINVAL);
1628
1629     if (size < 0 || size > 0x3FFFFFFF)
1630         return AVERROR(EINVAL);
1631
1632     if (is_relative(timestamp)) //FIXME this maintains previous behavior but we should shift by the correct offset once known
1633         timestamp -= RELATIVE_TS_BASE;
1634
1635     entries = av_fast_realloc(*index_entries,
1636                               index_entries_allocated_size,
1637                               (*nb_index_entries + 1) *
1638                               sizeof(AVIndexEntry));
1639     if(!entries)
1640         return -1;
1641
1642     *index_entries= entries;
1643
1644     index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1645
1646     if(index<0){
1647         index= (*nb_index_entries)++;
1648         ie= &entries[index];
1649         av_assert0(index==0 || ie[-1].timestamp < timestamp);
1650     }else{
1651         ie= &entries[index];
1652         if(ie->timestamp != timestamp){
1653             if(ie->timestamp <= timestamp)
1654                 return -1;
1655             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1656             (*nb_index_entries)++;
1657         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1658             distance= ie->min_distance;
1659     }
1660
1661     ie->pos = pos;
1662     ie->timestamp = timestamp;
1663     ie->min_distance= distance;
1664     ie->size= size;
1665     ie->flags = flags;
1666
1667     return index;
1668 }
1669
1670 int av_add_index_entry(AVStream *st,
1671                        int64_t pos, int64_t timestamp, int size, int distance, int flags)
1672 {
1673     timestamp = wrap_timestamp(st, timestamp);
1674     return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1675                               &st->index_entries_allocated_size, pos,
1676                               timestamp, size, distance, flags);
1677 }
1678
1679 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1680                               int64_t wanted_timestamp, int flags)
1681 {
1682     int a, b, m;
1683     int64_t timestamp;
1684
1685     a = - 1;
1686     b = nb_entries;
1687
1688     //optimize appending index entries at the end
1689     if(b && entries[b-1].timestamp < wanted_timestamp)
1690         a= b-1;
1691
1692     while (b - a > 1) {
1693         m = (a + b) >> 1;
1694         timestamp = entries[m].timestamp;
1695         if(timestamp >= wanted_timestamp)
1696             b = m;
1697         if(timestamp <= wanted_timestamp)
1698             a = m;
1699     }
1700     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1701
1702     if(!(flags & AVSEEK_FLAG_ANY)){
1703         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1704             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1705         }
1706     }
1707
1708     if(m == nb_entries)
1709         return -1;
1710     return  m;
1711 }
1712
1713 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1714                               int flags)
1715 {
1716     return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1717                                      wanted_timestamp, flags);
1718 }
1719
1720 static int64_t ff_read_timestamp(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit,
1721                                  int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1722 {
1723     int64_t ts = read_timestamp(s, stream_index, ppos, pos_limit);
1724     if (stream_index >= 0)
1725         ts = wrap_timestamp(s->streams[stream_index], ts);
1726     return ts;
1727 }
1728
1729 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1730 {
1731     AVInputFormat *avif= s->iformat;
1732     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1733     int64_t ts_min, ts_max, ts;
1734     int index;
1735     int64_t ret;
1736     AVStream *st;
1737
1738     if (stream_index < 0)
1739         return -1;
1740
1741     av_dlog(s, "read_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1742
1743     ts_max=
1744     ts_min= AV_NOPTS_VALUE;
1745     pos_limit= -1; //gcc falsely says it may be uninitialized
1746
1747     st= s->streams[stream_index];
1748     if(st->index_entries){
1749         AVIndexEntry *e;
1750
1751         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()
1752         index= FFMAX(index, 0);
1753         e= &st->index_entries[index];
1754
1755         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1756             pos_min= e->pos;
1757             ts_min= e->timestamp;
1758             av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%s\n",
1759                     pos_min, av_ts2str(ts_min));
1760         }else{
1761             av_assert1(index==0);
1762         }
1763
1764         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1765         av_assert0(index < st->nb_index_entries);
1766         if(index >= 0){
1767             e= &st->index_entries[index];
1768             av_assert1(e->timestamp >= target_ts);
1769             pos_max= e->pos;
1770             ts_max= e->timestamp;
1771             pos_limit= pos_max - e->min_distance;
1772             av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%s\n",
1773                     pos_max, pos_limit, av_ts2str(ts_max));
1774         }
1775     }
1776
1777     pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1778     if(pos<0)
1779         return -1;
1780
1781     /* do the seek */
1782     if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1783         return ret;
1784
1785     ff_read_frame_flush(s);
1786     ff_update_cur_dts(s, st, ts);
1787
1788     return 0;
1789 }
1790
1791 int ff_find_last_ts(AVFormatContext *s, int stream_index, int64_t *ts, int64_t *pos,
1792                     int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1793 {
1794     int64_t step= 1024;
1795     int64_t limit, ts_max;
1796     int64_t filesize = avio_size(s->pb);
1797     int64_t pos_max = filesize - 1;
1798     do{
1799         limit = pos_max;
1800         pos_max = FFMAX(0, (pos_max) - step);
1801         ts_max = ff_read_timestamp(s, stream_index, &pos_max, limit, read_timestamp);
1802         step += step;
1803     }while(ts_max == AV_NOPTS_VALUE && 2*limit > step);
1804     if (ts_max == AV_NOPTS_VALUE)
1805         return -1;
1806
1807     for(;;){
1808         int64_t tmp_pos = pos_max + 1;
1809         int64_t tmp_ts = ff_read_timestamp(s, stream_index, &tmp_pos, INT64_MAX, read_timestamp);
1810         if(tmp_ts == AV_NOPTS_VALUE)
1811             break;
1812         av_assert0(tmp_pos > pos_max);
1813         ts_max  = tmp_ts;
1814         pos_max = tmp_pos;
1815         if(tmp_pos >= filesize)
1816             break;
1817     }
1818
1819     if (ts)
1820         *ts = ts_max;
1821     if (pos)
1822         *pos = pos_max;
1823
1824     return 0;
1825 }
1826
1827 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1828                       int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1829                       int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1830                       int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1831 {
1832     int64_t pos, ts;
1833     int64_t start_pos;
1834     int no_change;
1835     int ret;
1836
1837     av_dlog(s, "gen_seek: %d %s\n", stream_index, av_ts2str(target_ts));
1838
1839     if(ts_min == AV_NOPTS_VALUE){
1840         pos_min = s->data_offset;
1841         ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1842         if (ts_min == AV_NOPTS_VALUE)
1843             return -1;
1844     }
1845
1846     if(ts_min >= target_ts){
1847         *ts_ret= ts_min;
1848         return pos_min;
1849     }
1850
1851     if(ts_max == AV_NOPTS_VALUE){
1852         if ((ret = ff_find_last_ts(s, stream_index, &ts_max, &pos_max, read_timestamp)) < 0)
1853             return ret;
1854         pos_limit= pos_max;
1855     }
1856
1857     if(ts_max <= target_ts){
1858         *ts_ret= ts_max;
1859         return pos_max;
1860     }
1861
1862     if(ts_min > ts_max){
1863         return -1;
1864     }else if(ts_min == ts_max){
1865         pos_limit= pos_min;
1866     }
1867
1868     no_change=0;
1869     while (pos_min < pos_limit) {
1870         av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%s dts_max=%s\n",
1871                 pos_min, pos_max, av_ts2str(ts_min), av_ts2str(ts_max));
1872         assert(pos_limit <= pos_max);
1873
1874         if(no_change==0){
1875             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1876             // interpolate position (better than dichotomy)
1877             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1878                 + pos_min - approximate_keyframe_distance;
1879         }else if(no_change==1){
1880             // bisection, if interpolation failed to change min or max pos last time
1881             pos = (pos_min + pos_limit)>>1;
1882         }else{
1883             /* linear search if bisection failed, can only happen if there
1884                are very few or no keyframes between min/max */
1885             pos=pos_min;
1886         }
1887         if(pos <= pos_min)
1888             pos= pos_min + 1;
1889         else if(pos > pos_limit)
1890             pos= pos_limit;
1891         start_pos= pos;
1892
1893         ts = ff_read_timestamp(s, stream_index, &pos, INT64_MAX, read_timestamp); //may pass pos_limit instead of -1
1894         if(pos == pos_max)
1895             no_change++;
1896         else
1897             no_change=0;
1898         av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %s %s %s target:%s limit:%"PRId64" start:%"PRId64" noc:%d\n",
1899                 pos_min, pos, pos_max,
1900                 av_ts2str(ts_min), av_ts2str(ts), av_ts2str(ts_max), av_ts2str(target_ts),
1901                 pos_limit, start_pos, no_change);
1902         if(ts == AV_NOPTS_VALUE){
1903             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1904             return -1;
1905         }
1906         assert(ts != AV_NOPTS_VALUE);
1907         if (target_ts <= ts) {
1908             pos_limit = start_pos - 1;
1909             pos_max = pos;
1910             ts_max = ts;
1911         }
1912         if (target_ts >= ts) {
1913             pos_min = pos;
1914             ts_min = ts;
1915         }
1916     }
1917
1918     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1919     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1920 #if 0
1921     pos_min = pos;
1922     ts_min = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1923     pos_min++;
1924     ts_max = ff_read_timestamp(s, stream_index, &pos_min, INT64_MAX, read_timestamp);
1925     av_dlog(s, "pos=0x%"PRIx64" %s<=%s<=%s\n",
1926             pos, av_ts2str(ts_min), av_ts2str(target_ts), av_ts2str(ts_max));
1927 #endif
1928     *ts_ret= ts;
1929     return pos;
1930 }
1931
1932 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1933     int64_t pos_min, pos_max;
1934
1935     pos_min = s->data_offset;
1936     pos_max = avio_size(s->pb) - 1;
1937
1938     if     (pos < pos_min) pos= pos_min;
1939     else if(pos > pos_max) pos= pos_max;
1940
1941     avio_seek(s->pb, pos, SEEK_SET);
1942
1943     s->io_repositioned = 1;
1944
1945     return 0;
1946 }
1947
1948 static int seek_frame_generic(AVFormatContext *s,
1949                                  int stream_index, int64_t timestamp, int flags)
1950 {
1951     int index;
1952     int64_t ret;
1953     AVStream *st;
1954     AVIndexEntry *ie;
1955
1956     st = s->streams[stream_index];
1957
1958     index = av_index_search_timestamp(st, timestamp, flags);
1959
1960     if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1961         return -1;
1962
1963     if(index < 0 || index==st->nb_index_entries-1){
1964         AVPacket pkt;
1965         int nonkey=0;
1966
1967         if(st->nb_index_entries){
1968             av_assert0(st->index_entries);
1969             ie= &st->index_entries[st->nb_index_entries-1];
1970             if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1971                 return ret;
1972             ff_update_cur_dts(s, st, ie->timestamp);
1973         }else{
1974             if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1975                 return ret;
1976         }
1977         for (;;) {
1978             int read_status;
1979             do{
1980                 read_status = av_read_frame(s, &pkt);
1981             } while (read_status == AVERROR(EAGAIN));
1982             if (read_status < 0)
1983                 break;
1984             av_free_packet(&pkt);
1985             if(stream_index == pkt.stream_index && pkt.dts > timestamp){
1986                 if(pkt.flags & AV_PKT_FLAG_KEY)
1987                     break;
1988                 if(nonkey++ > 1000 && st->codec->codec_id != AV_CODEC_ID_CDGRAPHICS){
1989                     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);
1990                     break;
1991                 }
1992             }
1993         }
1994         index = av_index_search_timestamp(st, timestamp, flags);
1995     }
1996     if (index < 0)
1997         return -1;
1998
1999     ff_read_frame_flush(s);
2000     if (s->iformat->read_seek){
2001         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
2002             return 0;
2003     }
2004     ie = &st->index_entries[index];
2005     if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
2006         return ret;
2007     ff_update_cur_dts(s, st, ie->timestamp);
2008
2009     return 0;
2010 }
2011
2012 static int seek_frame_internal(AVFormatContext *s, int stream_index,
2013                                int64_t timestamp, int flags)
2014 {
2015     int ret;
2016     AVStream *st;
2017
2018     if (flags & AVSEEK_FLAG_BYTE) {
2019         if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
2020             return -1;
2021         ff_read_frame_flush(s);
2022         return seek_frame_byte(s, stream_index, timestamp, flags);
2023     }
2024
2025     if(stream_index < 0){
2026         stream_index= av_find_default_stream_index(s);
2027         if(stream_index < 0)
2028             return -1;
2029
2030         st= s->streams[stream_index];
2031         /* timestamp for default must be expressed in AV_TIME_BASE units */
2032         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
2033     }
2034
2035     /* first, we try the format specific seek */
2036     if (s->iformat->read_seek) {
2037         ff_read_frame_flush(s);
2038         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
2039     } else
2040         ret = -1;
2041     if (ret >= 0) {
2042         return 0;
2043     }
2044
2045     if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
2046         ff_read_frame_flush(s);
2047         return ff_seek_frame_binary(s, stream_index, timestamp, flags);
2048     } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
2049         ff_read_frame_flush(s);
2050         return seek_frame_generic(s, stream_index, timestamp, flags);
2051     }
2052     else
2053         return -1;
2054 }
2055
2056 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
2057 {
2058     int ret;
2059
2060     if (s->iformat->read_seek2 && !s->iformat->read_seek) {
2061         int64_t min_ts = INT64_MIN, max_ts = INT64_MAX;
2062         if ((flags & AVSEEK_FLAG_BACKWARD))
2063             max_ts = timestamp;
2064         else
2065             min_ts = timestamp;
2066         return avformat_seek_file(s, stream_index, min_ts, timestamp, max_ts,
2067                                   flags & ~AVSEEK_FLAG_BACKWARD);
2068     }
2069
2070     ret = seek_frame_internal(s, stream_index, timestamp, flags);
2071
2072     if (ret >= 0)
2073         ret = avformat_queue_attached_pictures(s);
2074
2075     return ret;
2076 }
2077
2078 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
2079 {
2080     if(min_ts > ts || max_ts < ts)
2081         return -1;
2082     if (stream_index < -1 || stream_index >= (int)s->nb_streams)
2083         return AVERROR(EINVAL);
2084
2085     if(s->seek2any>0)
2086         flags |= AVSEEK_FLAG_ANY;
2087     flags &= ~AVSEEK_FLAG_BACKWARD;
2088
2089     if (s->iformat->read_seek2) {
2090         int ret;
2091         ff_read_frame_flush(s);
2092
2093         if (stream_index == -1 && s->nb_streams == 1) {
2094             AVRational time_base = s->streams[0]->time_base;
2095             ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
2096             min_ts = av_rescale_rnd(min_ts, time_base.den,
2097                                     time_base.num * (int64_t)AV_TIME_BASE,
2098                                     AV_ROUND_UP   | AV_ROUND_PASS_MINMAX);
2099             max_ts = av_rescale_rnd(max_ts, time_base.den,
2100                                     time_base.num * (int64_t)AV_TIME_BASE,
2101                                     AV_ROUND_DOWN | AV_ROUND_PASS_MINMAX);
2102         }
2103
2104         ret = s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
2105
2106         if (ret >= 0)
2107             ret = avformat_queue_attached_pictures(s);
2108         return ret;
2109     }
2110
2111     if(s->iformat->read_timestamp){
2112         //try to seek via read_timestamp()
2113     }
2114
2115     // Fall back on old API if new is not implemented but old is.
2116     // Note the old API has somewhat different semantics.
2117     if (s->iformat->read_seek || 1) {
2118         int dir = (ts - (uint64_t)min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0);
2119         int ret = av_seek_frame(s, stream_index, ts, flags | dir);
2120         if (ret<0 && ts != min_ts && max_ts != ts) {
2121             ret = av_seek_frame(s, stream_index, dir ? max_ts : min_ts, flags | dir);
2122             if (ret >= 0)
2123                 ret = av_seek_frame(s, stream_index, ts, flags | (dir^AVSEEK_FLAG_BACKWARD));
2124         }
2125         return ret;
2126     }
2127
2128     // try some generic seek like seek_frame_generic() but with new ts semantics
2129     return -1; //unreachable
2130 }
2131
2132 /*******************************************************/
2133
2134 /**
2135  * Return TRUE if the stream has accurate duration in any stream.
2136  *
2137  * @return TRUE if the stream has accurate duration for at least one component.
2138  */
2139 static int has_duration(AVFormatContext *ic)
2140 {
2141     int i;
2142     AVStream *st;
2143
2144     for(i = 0;i < ic->nb_streams; i++) {
2145         st = ic->streams[i];
2146         if (st->duration != AV_NOPTS_VALUE)
2147             return 1;
2148     }
2149     if (ic->duration != AV_NOPTS_VALUE)
2150         return 1;
2151     return 0;
2152 }
2153
2154 /**
2155  * Estimate the stream timings from the one of each components.
2156  *
2157  * Also computes the global bitrate if possible.
2158  */
2159 static void update_stream_timings(AVFormatContext *ic)
2160 {
2161     int64_t start_time, start_time1, start_time_text, end_time, end_time1;
2162     int64_t duration, duration1, filesize;
2163     int i;
2164     AVStream *st;
2165     AVProgram *p;
2166
2167     start_time = INT64_MAX;
2168     start_time_text = INT64_MAX;
2169     end_time = INT64_MIN;
2170     duration = INT64_MIN;
2171     for(i = 0;i < ic->nb_streams; i++) {
2172         st = ic->streams[i];
2173         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
2174             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
2175             if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE || st->codec->codec_type == AVMEDIA_TYPE_DATA) {
2176                 if (start_time1 < start_time_text)
2177                     start_time_text = start_time1;
2178             } else
2179                 start_time = FFMIN(start_time, start_time1);
2180             end_time1 = AV_NOPTS_VALUE;
2181             if (st->duration != AV_NOPTS_VALUE) {
2182                 end_time1 = start_time1
2183                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2184                 end_time = FFMAX(end_time, end_time1);
2185             }
2186             for(p = NULL; (p = av_find_program_from_stream(ic, p, i)); ){
2187                 if(p->start_time == AV_NOPTS_VALUE || p->start_time > start_time1)
2188                     p->start_time = start_time1;
2189                 if(p->end_time < end_time1)
2190                     p->end_time = end_time1;
2191             }
2192         }
2193         if (st->duration != AV_NOPTS_VALUE) {
2194             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
2195             duration = FFMAX(duration, duration1);
2196         }
2197     }
2198     if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
2199         start_time = start_time_text;
2200     else if(start_time > start_time_text)
2201         av_log(ic, AV_LOG_VERBOSE, "Ignoring outlier non primary stream starttime %f\n", start_time_text / (float)AV_TIME_BASE);
2202
2203     if (start_time != INT64_MAX) {
2204         ic->start_time = start_time;
2205         if (end_time != INT64_MIN) {
2206             if (ic->nb_programs) {
2207                 for (i=0; i<ic->nb_programs; i++) {
2208                     p = ic->programs[i];
2209                     if(p->start_time != AV_NOPTS_VALUE && p->end_time > p->start_time)
2210                         duration = FFMAX(duration, p->end_time - p->start_time);
2211                 }
2212             } else
2213                 duration = FFMAX(duration, end_time - start_time);
2214         }
2215     }
2216     if (duration != INT64_MIN && duration > 0 && ic->duration == AV_NOPTS_VALUE) {
2217         ic->duration = duration;
2218     }
2219         if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
2220             /* compute the bitrate */
2221             double bitrate = (double)filesize * 8.0 * AV_TIME_BASE /
2222                 (double)ic->duration;
2223             if (bitrate >= 0 && bitrate <= INT_MAX)
2224                 ic->bit_rate = bitrate;
2225         }
2226 }
2227
2228 static void fill_all_stream_timings(AVFormatContext *ic)
2229 {
2230     int i;
2231     AVStream *st;
2232
2233     update_stream_timings(ic);
2234     for(i = 0;i < ic->nb_streams; i++) {
2235         st = ic->streams[i];
2236         if (st->start_time == AV_NOPTS_VALUE) {
2237             if(ic->start_time != AV_NOPTS_VALUE)
2238                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2239             if(ic->duration != AV_NOPTS_VALUE)
2240                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2241         }
2242     }
2243 }
2244
2245 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2246 {
2247     int64_t filesize, duration;
2248     int i, show_warning = 0;
2249     AVStream *st;
2250
2251     /* if bit_rate is already set, we believe it */
2252     if (ic->bit_rate <= 0) {
2253         int bit_rate = 0;
2254         for(i=0;i<ic->nb_streams;i++) {
2255             st = ic->streams[i];
2256             if (st->codec->bit_rate > 0) {
2257                 if (INT_MAX - st->codec->bit_rate < bit_rate) {
2258                     bit_rate = 0;
2259                     break;
2260                 }
2261                 bit_rate += st->codec->bit_rate;
2262             }
2263         }
2264         ic->bit_rate = bit_rate;
2265     }
2266
2267     /* if duration is already set, we believe it */
2268     if (ic->duration == AV_NOPTS_VALUE &&
2269         ic->bit_rate != 0) {
2270         filesize = ic->pb ? avio_size(ic->pb) : 0;
2271         if (filesize > 0) {
2272             for(i = 0; i < ic->nb_streams; i++) {
2273                 st = ic->streams[i];
2274                 if (   st->time_base.num <= INT64_MAX / ic->bit_rate
2275                     && st->duration == AV_NOPTS_VALUE) {
2276                     duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2277                     st->duration = duration;
2278                     show_warning = 1;
2279                 }
2280             }
2281         }
2282     }
2283     if (show_warning)
2284         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2285 }
2286
2287 #define DURATION_MAX_READ_SIZE 250000LL
2288 #define DURATION_MAX_RETRY 4
2289
2290 /* only usable for MPEG-PS streams */
2291 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2292 {
2293     AVPacket pkt1, *pkt = &pkt1;
2294     AVStream *st;
2295     int read_size, i, ret;
2296     int64_t end_time;
2297     int64_t filesize, offset, duration;
2298     int retry=0;
2299
2300     /* flush packet queue */
2301     flush_packet_queue(ic);
2302
2303     for (i=0; i<ic->nb_streams; i++) {
2304         st = ic->streams[i];
2305         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2306             av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2307
2308         if (st->parser) {
2309             av_parser_close(st->parser);
2310             st->parser= NULL;
2311         }
2312     }
2313
2314     /* estimate the end time (duration) */
2315     /* XXX: may need to support wrapping */
2316     filesize = ic->pb ? avio_size(ic->pb) : 0;
2317     end_time = AV_NOPTS_VALUE;
2318     do{
2319         offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2320         if (offset < 0)
2321             offset = 0;
2322
2323         avio_seek(ic->pb, offset, SEEK_SET);
2324         read_size = 0;
2325         for(;;) {
2326             if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2327                 break;
2328
2329             do {
2330                 ret = ff_read_packet(ic, pkt);
2331             } while(ret == AVERROR(EAGAIN));
2332             if (ret != 0)
2333                 break;
2334             read_size += pkt->size;
2335             st = ic->streams[pkt->stream_index];
2336             if (pkt->pts != AV_NOPTS_VALUE &&
2337                 (st->start_time != AV_NOPTS_VALUE ||
2338                  st->first_dts  != AV_NOPTS_VALUE)) {
2339                 duration = end_time = pkt->pts;
2340                 if (st->start_time != AV_NOPTS_VALUE)
2341                     duration -= st->start_time;
2342                 else
2343                     duration -= st->first_dts;
2344                 if (duration > 0) {
2345                     if (st->duration == AV_NOPTS_VALUE || st->info->last_duration<=0 ||
2346                         (st->duration < duration && FFABS(duration - st->info->last_duration) < 60LL*st->time_base.den / st->time_base.num))
2347                         st->duration = duration;
2348                     st->info->last_duration = duration;
2349                 }
2350             }
2351             av_free_packet(pkt);
2352         }
2353     }while(   end_time==AV_NOPTS_VALUE
2354            && filesize > (DURATION_MAX_READ_SIZE<<retry)
2355            && ++retry <= DURATION_MAX_RETRY);
2356
2357     fill_all_stream_timings(ic);
2358
2359     avio_seek(ic->pb, old_offset, SEEK_SET);
2360     for (i=0; i<ic->nb_streams; i++) {
2361         st= ic->streams[i];
2362         st->cur_dts= st->first_dts;
2363         st->last_IP_pts = AV_NOPTS_VALUE;
2364     }
2365 }
2366
2367 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2368 {
2369     int64_t file_size;
2370
2371     /* get the file size, if possible */
2372     if (ic->iformat->flags & AVFMT_NOFILE) {
2373         file_size = 0;
2374     } else {
2375         file_size = avio_size(ic->pb);
2376         file_size = FFMAX(0, file_size);
2377     }
2378
2379     if ((!strcmp(ic->iformat->name, "mpeg") ||
2380          !strcmp(ic->iformat->name, "mpegts")) &&
2381         file_size && ic->pb->seekable) {
2382         /* get accurate estimate from the PTSes */
2383         estimate_timings_from_pts(ic, old_offset);
2384         ic->duration_estimation_method = AVFMT_DURATION_FROM_PTS;
2385     } else if (has_duration(ic)) {
2386         /* at least one component has timings - we use them for all
2387            the components */
2388         fill_all_stream_timings(ic);
2389         ic->duration_estimation_method = AVFMT_DURATION_FROM_STREAM;
2390     } else {
2391         /* less precise: use bitrate info */
2392         estimate_timings_from_bit_rate(ic);
2393         ic->duration_estimation_method = AVFMT_DURATION_FROM_BITRATE;
2394     }
2395     update_stream_timings(ic);
2396
2397     {
2398         int i;
2399         AVStream av_unused *st;
2400         for(i = 0;i < ic->nb_streams; i++) {
2401             st = ic->streams[i];
2402             av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2403                     (double) st->start_time / AV_TIME_BASE,
2404                     (double) st->duration   / AV_TIME_BASE);
2405         }
2406         av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2407                 (double) ic->start_time / AV_TIME_BASE,
2408                 (double) ic->duration   / AV_TIME_BASE,
2409                 ic->bit_rate / 1000);
2410     }
2411 }
2412
2413 static int has_codec_parameters(AVStream *st, const char **errmsg_ptr)
2414 {
2415     AVCodecContext *avctx = st->codec;
2416
2417 #define FAIL(errmsg) do {                                         \
2418         if (errmsg_ptr)                                           \
2419             *errmsg_ptr = errmsg;                                 \
2420         return 0;                                                 \
2421     } while (0)
2422
2423     switch (avctx->codec_type) {
2424     case AVMEDIA_TYPE_AUDIO:
2425         if (!avctx->frame_size && determinable_frame_size(avctx))
2426             FAIL("unspecified frame size");
2427         if (st->info->found_decoder >= 0 && avctx->sample_fmt == AV_SAMPLE_FMT_NONE)
2428             FAIL("unspecified sample format");
2429         if (!avctx->sample_rate)
2430             FAIL("unspecified sample rate");
2431         if (!avctx->channels)
2432             FAIL("unspecified number of channels");
2433         if (st->info->found_decoder >= 0 && !st->nb_decoded_frames && avctx->codec_id == AV_CODEC_ID_DTS)
2434             FAIL("no decodable DTS frames");
2435         break;
2436     case AVMEDIA_TYPE_VIDEO:
2437         if (!avctx->width)
2438             FAIL("unspecified size");
2439         if (st->info->found_decoder >= 0 && avctx->pix_fmt == AV_PIX_FMT_NONE)
2440             FAIL("unspecified pixel format");
2441         if (st->codec->codec_id == AV_CODEC_ID_RV30 || st->codec->codec_id == AV_CODEC_ID_RV40)
2442             if (!st->sample_aspect_ratio.num && !st->codec->sample_aspect_ratio.num && !st->codec_info_nb_frames)
2443                 FAIL("no frame in rv30/40 and no sar");
2444         break;
2445     case AVMEDIA_TYPE_SUBTITLE:
2446         if (avctx->codec_id == AV_CODEC_ID_HDMV_PGS_SUBTITLE && !avctx->width)
2447             FAIL("unspecified size");
2448         break;
2449     case AVMEDIA_TYPE_DATA:
2450         if(avctx->codec_id == AV_CODEC_ID_NONE) return 1;
2451     }
2452
2453     if (avctx->codec_id == AV_CODEC_ID_NONE)
2454         FAIL("unknown codec");
2455     return 1;
2456 }
2457
2458 /* returns 1 or 0 if or if not decoded data was returned, or a negative error */
2459 static int try_decode_frame(AVFormatContext *s, AVStream *st, AVPacket *avpkt, AVDictionary **options)
2460 {
2461     const AVCodec *codec;
2462     int got_picture = 1, ret = 0;
2463     AVFrame *frame = av_frame_alloc();
2464     AVSubtitle subtitle;
2465     AVPacket pkt = *avpkt;
2466
2467     if (!frame)
2468         return AVERROR(ENOMEM);
2469
2470     if (!avcodec_is_open(st->codec) && !st->info->found_decoder) {
2471         AVDictionary *thread_opt = NULL;
2472
2473         codec = find_decoder(s, st, st->codec->codec_id);
2474
2475         if (!codec) {
2476             st->info->found_decoder = -1;
2477             ret = -1;
2478             goto fail;
2479         }
2480
2481         /* force thread count to 1 since the h264 decoder will not extract SPS
2482          *  and PPS to extradata during multi-threaded decoding */
2483         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2484         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2485         if (!options)
2486             av_dict_free(&thread_opt);
2487         if (ret < 0) {
2488             st->info->found_decoder = -1;
2489             goto fail;
2490         }
2491         st->info->found_decoder = 1;
2492     } else if (!st->info->found_decoder)
2493         st->info->found_decoder = 1;
2494
2495     if (st->info->found_decoder < 0) {
2496         ret = -1;
2497         goto fail;
2498     }
2499
2500     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2501            ret >= 0 &&
2502            (!has_codec_parameters(st, NULL)   ||
2503            !has_decode_delay_been_guessed(st) ||
2504            (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2505         got_picture = 0;
2506         avcodec_get_frame_defaults(frame);
2507         switch(st->codec->codec_type) {
2508         case AVMEDIA_TYPE_VIDEO:
2509             ret = avcodec_decode_video2(st->codec, frame,
2510                                         &got_picture, &pkt);
2511             break;
2512         case AVMEDIA_TYPE_AUDIO:
2513             ret = avcodec_decode_audio4(st->codec, frame, &got_picture, &pkt);
2514             break;
2515         case AVMEDIA_TYPE_SUBTITLE:
2516             ret = avcodec_decode_subtitle2(st->codec, &subtitle,
2517                                            &got_picture, &pkt);
2518             ret = pkt.size;
2519             break;
2520         default:
2521             break;
2522         }
2523         if (ret >= 0) {
2524             if (got_picture)
2525                 st->nb_decoded_frames++;
2526             pkt.data += ret;
2527             pkt.size -= ret;
2528             ret       = got_picture;
2529         }
2530     }
2531
2532     if(!pkt.data && !got_picture)
2533         ret = -1;
2534
2535 fail:
2536     avcodec_free_frame(&frame);
2537     return ret;
2538 }
2539
2540 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
2541 {
2542     while (tags->id != AV_CODEC_ID_NONE) {
2543         if (tags->id == id)
2544             return tags->tag;
2545         tags++;
2546     }
2547     return 0;
2548 }
2549
2550 enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2551 {
2552     int i;
2553     for(i=0; tags[i].id != AV_CODEC_ID_NONE;i++) {
2554         if(tag == tags[i].tag)
2555             return tags[i].id;
2556     }
2557     for(i=0; tags[i].id != AV_CODEC_ID_NONE; i++) {
2558         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2559             return tags[i].id;
2560     }
2561     return AV_CODEC_ID_NONE;
2562 }
2563
2564 enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
2565 {
2566     if (flt) {
2567         switch (bps) {
2568         case 32: return be ? AV_CODEC_ID_PCM_F32BE : AV_CODEC_ID_PCM_F32LE;
2569         case 64: return be ? AV_CODEC_ID_PCM_F64BE : AV_CODEC_ID_PCM_F64LE;
2570         default: return AV_CODEC_ID_NONE;
2571         }
2572     } else {
2573         bps  += 7;
2574         bps >>= 3;
2575         if (sflags & (1 << (bps - 1))) {
2576             switch (bps) {
2577             case 1:  return AV_CODEC_ID_PCM_S8;
2578             case 2:  return be ? AV_CODEC_ID_PCM_S16BE : AV_CODEC_ID_PCM_S16LE;
2579             case 3:  return be ? AV_CODEC_ID_PCM_S24BE : AV_CODEC_ID_PCM_S24LE;
2580             case 4:  return be ? AV_CODEC_ID_PCM_S32BE : AV_CODEC_ID_PCM_S32LE;
2581             default: return AV_CODEC_ID_NONE;
2582             }
2583         } else {
2584             switch (bps) {
2585             case 1:  return AV_CODEC_ID_PCM_U8;
2586             case 2:  return be ? AV_CODEC_ID_PCM_U16BE : AV_CODEC_ID_PCM_U16LE;
2587             case 3:  return be ? AV_CODEC_ID_PCM_U24BE : AV_CODEC_ID_PCM_U24LE;
2588             case 4:  return be ? AV_CODEC_ID_PCM_U32BE : AV_CODEC_ID_PCM_U32LE;
2589             default: return AV_CODEC_ID_NONE;
2590             }
2591         }
2592     }
2593 }
2594
2595 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum AVCodecID id)
2596 {
2597     unsigned int tag;
2598     if (!av_codec_get_tag2(tags, id, &tag))
2599         return 0;
2600     return tag;
2601 }
2602
2603 int av_codec_get_tag2(const AVCodecTag * const *tags, enum AVCodecID id,
2604                       unsigned int *tag)
2605 {
2606     int i;
2607     for(i=0; tags && tags[i]; i++){
2608         const AVCodecTag *codec_tags = tags[i];
2609         while (codec_tags->id != AV_CODEC_ID_NONE) {
2610             if (codec_tags->id == id) {
2611                 *tag = codec_tags->tag;
2612                 return 1;
2613             }
2614             codec_tags++;
2615         }
2616     }
2617     return 0;
2618 }
2619
2620 enum AVCodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2621 {
2622     int i;
2623     for(i=0; tags && tags[i]; i++){
2624         enum AVCodecID id= ff_codec_get_id(tags[i], tag);
2625         if(id!=AV_CODEC_ID_NONE) return id;
2626     }
2627     return AV_CODEC_ID_NONE;
2628 }
2629
2630 static void compute_chapters_end(AVFormatContext *s)
2631 {
2632     unsigned int i, j;
2633     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2634
2635     for (i = 0; i < s->nb_chapters; i++)
2636         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2637             AVChapter *ch = s->chapters[i];
2638             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2639                                      : INT64_MAX;
2640
2641             for (j = 0; j < s->nb_chapters; j++) {
2642                 AVChapter *ch1 = s->chapters[j];
2643                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2644                 if (j != i && next_start > ch->start && next_start < end)
2645                     end = next_start;
2646             }
2647             ch->end = (end == INT64_MAX) ? ch->start : end;
2648         }
2649 }
2650
2651 static int get_std_framerate(int i){
2652     if(i<60*12) return (i+1)*1001;
2653     else        return ((const int[]){24,30,60,12,15,48})[i-60*12]*1000*12;
2654 }
2655
2656 /*
2657  * Is the time base unreliable.
2658  * This is a heuristic to balance between quick acceptance of the values in
2659  * the headers vs. some extra checks.
2660  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2661  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2662  * And there are "variable" fps files this needs to detect as well.
2663  */
2664 static int tb_unreliable(AVCodecContext *c){
2665     if(   c->time_base.den >= 101L*c->time_base.num
2666        || c->time_base.den <    5L*c->time_base.num
2667 /*       || c->codec_tag == AV_RL32("DIVX")
2668        || c->codec_tag == AV_RL32("XVID")*/
2669        || c->codec_tag == AV_RL32("mp4v")
2670        || c->codec_id == AV_CODEC_ID_MPEG2VIDEO
2671        || c->codec_id == AV_CODEC_ID_H264
2672        )
2673         return 1;
2674     return 0;
2675 }
2676
2677 #if FF_API_FORMAT_PARAMETERS
2678 int av_find_stream_info(AVFormatContext *ic)
2679 {
2680     return avformat_find_stream_info(ic, NULL);
2681 }
2682 #endif
2683
2684 int ff_alloc_extradata(AVCodecContext *avctx, int size)
2685 {
2686     int ret;
2687
2688     if (size < 0 || size >= INT32_MAX - FF_INPUT_BUFFER_PADDING_SIZE) {
2689         avctx->extradata_size = 0;
2690         return AVERROR(EINVAL);
2691     }
2692     avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
2693     if (avctx->extradata) {
2694         memset(avctx->extradata + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2695         avctx->extradata_size = size;
2696         ret = 0;
2697     } else {
2698         avctx->extradata_size = 0;
2699         ret = AVERROR(ENOMEM);
2700     }
2701     return ret;
2702 }
2703
2704 int ff_rfps_add_frame(AVFormatContext *ic, AVStream *st, int64_t ts)
2705 {
2706     int i, j;
2707     int64_t last = st->info->last_dts;
2708
2709     if(   ts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && ts > last
2710        && ts - (uint64_t)last < INT64_MAX){
2711         double dts= (is_relative(ts) ?  ts - RELATIVE_TS_BASE : ts) * av_q2d(st->time_base);
2712         int64_t duration= ts - last;
2713
2714         if (!st->info->duration_error)
2715             st->info->duration_error = av_mallocz(sizeof(st->info->duration_error[0])*2);
2716         if (!st->info->duration_error)
2717             return AVERROR(ENOMEM);
2718
2719 //         if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2720 //             av_log(NULL, AV_LOG_ERROR, "%f\n", dts);
2721         for (i=0; i<MAX_STD_TIMEBASES; i++) {
2722             int framerate= get_std_framerate(i);
2723             double sdts= dts*framerate/(1001*12);
2724             for(j=0; j<2; j++){
2725                 int64_t ticks= llrint(sdts+j*0.5);
2726                 double error= sdts - ticks + j*0.5;
2727                 st->info->duration_error[j][0][i] += error;
2728                 st->info->duration_error[j][1][i] += error*error;
2729             }
2730         }
2731         st->info->duration_count++;
2732         // ignore the first 4 values, they might have some random jitter
2733         if (st->info->duration_count > 3 && is_relative(ts) == is_relative(last))
2734             st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2735     }
2736     if (ts != AV_NOPTS_VALUE)
2737         st->info->last_dts = ts;
2738
2739     return 0;
2740 }
2741
2742 void ff_rfps_calculate(AVFormatContext *ic)
2743 {
2744     int i, j;
2745
2746     for (i = 0; i<ic->nb_streams; i++) {
2747         AVStream *st = ic->streams[i];
2748
2749         if (st->codec->codec_type != AVMEDIA_TYPE_VIDEO)
2750             continue;
2751         // the check for tb_unreliable() is not completely correct, since this is not about handling
2752         // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2753         // ipmovie.c produces.
2754         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)
2755             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);
2756         if (st->info->duration_count>1 && !st->r_frame_rate.num
2757             && tb_unreliable(st->codec)) {
2758             int num = 0;
2759             double best_error= 0.01;
2760
2761             for (j=0; j<MAX_STD_TIMEBASES; j++) {
2762                 int k;
2763
2764                 if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2765                     continue;
2766                 if(!st->info->codec_info_duration && 1.0 < (1001*12.0)/get_std_framerate(j))
2767                     continue;
2768                 for(k=0; k<2; k++){
2769                     int n= st->info->duration_count;
2770                     double a= st->info->duration_error[k][0][j] / n;
2771                     double error= st->info->duration_error[k][1][j]/n - a*a;
2772
2773                     if(error < best_error && best_error> 0.000000001){
2774                         best_error= error;
2775                         num = get_std_framerate(j);
2776                     }
2777                     if(error < 0.02)
2778                         av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2779                 }
2780             }
2781             // do not increase frame rate by more than 1 % in order to match a standard rate.
2782             if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2783                 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2784         }
2785
2786         av_freep(&st->info->duration_error);
2787         st->info->last_dts = AV_NOPTS_VALUE;
2788         st->info->duration_count = 0;
2789     }
2790 }
2791
2792 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2793 {
2794     int i, count, ret = 0, j;
2795     int64_t read_size;
2796     AVStream *st;
2797     AVPacket pkt1, *pkt;
2798     int64_t old_offset = avio_tell(ic->pb);
2799     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2800     int flush_codecs = ic->probesize > 0;
2801
2802     if(ic->pb)
2803         av_log(ic, AV_LOG_DEBUG, "Before avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d\n",
2804                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count);
2805
2806     for(i=0;i<ic->nb_streams;i++) {
2807         const AVCodec *codec;
2808         AVDictionary *thread_opt = NULL;
2809         st = ic->streams[i];
2810
2811         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2812             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2813 /*            if(!st->time_base.num)
2814                 st->time_base= */
2815             if(!st->codec->time_base.num)
2816                 st->codec->time_base= st->time_base;
2817         }
2818         //only for the split stuff
2819         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2820             st->parser = av_parser_init(st->codec->codec_id);
2821             if(st->parser){
2822                 if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
2823                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2824                 } else if(st->need_parsing == AVSTREAM_PARSE_FULL_RAW) {
2825                     st->parser->flags |= PARSER_FLAG_USE_CODEC_TS;
2826                 }
2827             } else if (st->need_parsing) {
2828                 av_log(ic, AV_LOG_VERBOSE, "parser not found for codec "
2829                        "%s, packets or times may be invalid.\n",
2830                        avcodec_get_name(st->codec->codec_id));
2831             }
2832         }
2833         codec = find_decoder(ic, st, st->codec->codec_id);
2834
2835         /* force thread count to 1 since the h264 decoder will not extract SPS
2836          *  and PPS to extradata during multi-threaded decoding */
2837         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2838
2839         /* Ensure that subtitle_header is properly set. */
2840         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2841             && codec && !st->codec->codec)
2842             avcodec_open2(st->codec, codec, options ? &options[i]
2843                               : &thread_opt);
2844
2845         //try to just open decoders, in case this is enough to get parameters
2846         if (!has_codec_parameters(st, NULL) && st->request_probe <= 0) {
2847             if (codec && !st->codec->codec)
2848                 avcodec_open2(st->codec, codec, options ? &options[i]
2849                               : &thread_opt);
2850         }
2851         if (!options)
2852             av_dict_free(&thread_opt);
2853     }
2854
2855     for (i=0; i<ic->nb_streams; i++) {
2856 #if FF_API_R_FRAME_RATE
2857         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2858 #endif
2859         ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
2860         ic->streams[i]->info->fps_last_dts  = AV_NOPTS_VALUE;
2861     }
2862
2863     count = 0;
2864     read_size = 0;
2865     for(;;) {
2866         if (ff_check_interrupt(&ic->interrupt_callback)){
2867             ret= AVERROR_EXIT;
2868             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2869             break;
2870         }
2871
2872         /* check if one codec still needs to be handled */
2873         for(i=0;i<ic->nb_streams;i++) {
2874             int fps_analyze_framecount = 20;
2875
2876             st = ic->streams[i];
2877             if (!has_codec_parameters(st, NULL))
2878                 break;
2879             /* if the timebase is coarse (like the usual millisecond precision
2880                of mkv), we need to analyze more frames to reliably arrive at
2881                the correct fps */
2882             if (av_q2d(st->time_base) > 0.0005)
2883                 fps_analyze_framecount *= 2;
2884             if (ic->fps_probe_size >= 0)
2885                 fps_analyze_framecount = ic->fps_probe_size;
2886             if (st->disposition & AV_DISPOSITION_ATTACHED_PIC)
2887                 fps_analyze_framecount = 0;
2888             /* variable fps and no guess at the real fps */
2889             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2890                && st->info->duration_count < fps_analyze_framecount
2891                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2892                 break;
2893             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2894                 break;
2895             if (st->first_dts == AV_NOPTS_VALUE &&
2896                 (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2897                  st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2898                 break;
2899         }
2900         if (i == ic->nb_streams) {
2901             /* NOTE: if the format has no header, then we need to read
2902                some packets to get most of the streams, so we cannot
2903                stop here */
2904             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2905                 /* if we found the info for all the codecs, we can stop */
2906                 ret = count;
2907                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2908                 flush_codecs = 0;
2909                 break;
2910             }
2911         }
2912         /* we did not get all the codec info, but we read too much data */
2913         if (read_size >= ic->probesize) {
2914             ret = count;
2915             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit of %d bytes reached\n", ic->probesize);
2916             for (i = 0; i < ic->nb_streams; i++)
2917                 if (!ic->streams[i]->r_frame_rate.num &&
2918                     ic->streams[i]->info->duration_count <= 1 &&
2919                     strcmp(ic->iformat->name, "image2"))
2920                     av_log(ic, AV_LOG_WARNING,
2921                            "Stream #%d: not enough frames to estimate rate; "
2922                            "consider increasing probesize\n", i);
2923             break;
2924         }
2925
2926         /* NOTE: a new stream can be added there if no header in file
2927            (AVFMTCTX_NOHEADER) */
2928         ret = read_frame_internal(ic, &pkt1);
2929         if (ret == AVERROR(EAGAIN))
2930             continue;
2931
2932         if (ret < 0) {
2933             /* EOF or error*/
2934             break;
2935         }
2936
2937         if (ic->flags & AVFMT_FLAG_NOBUFFER)
2938             free_packet_buffer(&ic->packet_buffer, &ic->packet_buffer_end);
2939         {
2940             pkt = add_to_pktbuf(&ic->packet_buffer, &pkt1,
2941                                 &ic->packet_buffer_end);
2942             if (!pkt) {
2943                 ret = AVERROR(ENOMEM);
2944                 goto find_stream_info_err;
2945             }
2946             if ((ret = av_dup_packet(pkt)) < 0)
2947                 goto find_stream_info_err;
2948         }
2949
2950         st = ic->streams[pkt->stream_index];
2951         if (!(st->disposition & AV_DISPOSITION_ATTACHED_PIC))
2952             read_size += pkt->size;
2953
2954         if (pkt->dts != AV_NOPTS_VALUE && st->codec_info_nb_frames > 1) {
2955             /* check for non-increasing dts */
2956             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2957                 st->info->fps_last_dts >= pkt->dts) {
2958                 av_log(ic, AV_LOG_DEBUG, "Non-increasing DTS in stream %d: "
2959                        "packet %d with DTS %"PRId64", packet %d with DTS "
2960                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2961                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2962                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2963             }
2964             /* check for a discontinuity in dts - if the difference in dts
2965              * is more than 1000 times the average packet duration in the sequence,
2966              * we treat it as a discontinuity */
2967             if (st->info->fps_last_dts != AV_NOPTS_VALUE &&
2968                 st->info->fps_last_dts_idx > st->info->fps_first_dts_idx &&
2969                 (pkt->dts - st->info->fps_last_dts) / 1000 >
2970                 (st->info->fps_last_dts - st->info->fps_first_dts) / (st->info->fps_last_dts_idx - st->info->fps_first_dts_idx)) {
2971                 av_log(ic, AV_LOG_WARNING, "DTS discontinuity in stream %d: "
2972                        "packet %d with DTS %"PRId64", packet %d with DTS "
2973                        "%"PRId64"\n", st->index, st->info->fps_last_dts_idx,
2974                        st->info->fps_last_dts, st->codec_info_nb_frames, pkt->dts);
2975                 st->info->fps_first_dts = st->info->fps_last_dts = AV_NOPTS_VALUE;
2976             }
2977
2978             /* update stored dts values */
2979             if (st->info->fps_first_dts == AV_NOPTS_VALUE) {
2980                 st->info->fps_first_dts     = pkt->dts;
2981                 st->info->fps_first_dts_idx = st->codec_info_nb_frames;
2982             }
2983             st->info->fps_last_dts = pkt->dts;
2984             st->info->fps_last_dts_idx = st->codec_info_nb_frames;
2985         }
2986         if (st->codec_info_nb_frames>1) {
2987             int64_t t=0;
2988             if (st->time_base.den > 0)
2989                 t = av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q);
2990             if (st->avg_frame_rate.num > 0)
2991                 t = FFMAX(t, av_rescale_q(st->codec_info_nb_frames, av_inv_q(st->avg_frame_rate), AV_TIME_BASE_Q));
2992
2993             if (   t==0
2994                 && st->codec_info_nb_frames>30
2995                 && st->info->fps_first_dts != AV_NOPTS_VALUE
2996                 && st->info->fps_last_dts  != AV_NOPTS_VALUE)
2997                 t = FFMAX(t, av_rescale_q(st->info->fps_last_dts - st->info->fps_first_dts, st->time_base, AV_TIME_BASE_Q));
2998
2999             if (t >= ic->max_analyze_duration) {
3000                 av_log(ic, AV_LOG_VERBOSE, "max_analyze_duration %d reached at %"PRId64" microseconds\n", ic->max_analyze_duration, t);
3001                 break;
3002             }
3003             if (pkt->duration) {
3004                 st->info->codec_info_duration        += pkt->duration;
3005                 st->info->codec_info_duration_fields += st->parser && st->need_parsing && st->codec->ticks_per_frame==2 ? st->parser->repeat_pict + 1 : 2;
3006             }
3007         }
3008 #if FF_API_R_FRAME_RATE
3009         ff_rfps_add_frame(ic, st, pkt->dts);
3010 #endif
3011         if(st->parser && st->parser->parser->split && !st->codec->extradata){
3012             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
3013             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
3014                 if (ff_alloc_extradata(st->codec, i))
3015                     return AVERROR(ENOMEM);
3016                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
3017             }
3018         }
3019
3020         /* if still no information, we try to open the codec and to
3021            decompress the frame. We try to avoid that in most cases as
3022            it takes longer and uses more memory. For MPEG-4, we need to
3023            decompress for QuickTime.
3024
3025            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
3026            least one frame of codec data, this makes sure the codec initializes
3027            the channel configuration and does not only trust the values from the container.
3028         */
3029         try_decode_frame(ic, st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
3030
3031         st->codec_info_nb_frames++;
3032         count++;
3033     }
3034
3035     if (flush_codecs) {
3036         AVPacket empty_pkt = { 0 };
3037         int err = 0;
3038         av_init_packet(&empty_pkt);
3039
3040         for(i=0;i<ic->nb_streams;i++) {
3041
3042             st = ic->streams[i];
3043
3044             /* flush the decoders */
3045             if (st->info->found_decoder == 1) {
3046                 do {
3047                     err = try_decode_frame(ic, st, &empty_pkt,
3048                                             (options && i < orig_nb_streams) ?
3049                                             &options[i] : NULL);
3050                 } while (err > 0 && !has_codec_parameters(st, NULL));
3051
3052                 if (err < 0) {
3053                     av_log(ic, AV_LOG_INFO,
3054                         "decoding for stream %d failed\n", st->index);
3055                 }
3056             }
3057         }
3058     }
3059
3060     // close codecs which were opened in try_decode_frame()
3061     for(i=0;i<ic->nb_streams;i++) {
3062         st = ic->streams[i];
3063         avcodec_close(st->codec);
3064     }
3065
3066     ff_rfps_calculate(ic);
3067
3068     for(i=0;i<ic->nb_streams;i++) {
3069         st = ic->streams[i];
3070         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3071             if(st->codec->codec_id == AV_CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
3072                 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
3073                 if (avpriv_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
3074                     st->codec->codec_tag= tag;
3075             }
3076
3077             /* estimate average framerate if not set by demuxer */
3078             if (st->info->codec_info_duration_fields && !st->avg_frame_rate.num && st->info->codec_info_duration) {
3079                 int      best_fps = 0;
3080                 double best_error = 0.01;
3081
3082                 if (st->info->codec_info_duration        >= INT64_MAX / st->time_base.num / 2||
3083                     st->info->codec_info_duration_fields >= INT64_MAX / st->time_base.den ||
3084                     st->info->codec_info_duration        < 0)
3085                     continue;
3086                 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3087                           st->info->codec_info_duration_fields*(int64_t)st->time_base.den,
3088                           st->info->codec_info_duration*2*(int64_t)st->time_base.num, 60000);
3089
3090                 /* round guessed framerate to a "standard" framerate if it's
3091                  * within 1% of the original estimate*/
3092                 for (j = 1; j < MAX_STD_TIMEBASES; j++) {
3093                     AVRational std_fps = { get_std_framerate(j), 12*1001 };
3094                     double error = fabs(av_q2d(st->avg_frame_rate) / av_q2d(std_fps) - 1);
3095
3096                     if (error < best_error) {
3097                         best_error = error;
3098                         best_fps   = std_fps.num;
3099                     }
3100                 }
3101                 if (best_fps) {
3102                     av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
3103                               best_fps, 12*1001, INT_MAX);
3104                 }
3105             }
3106
3107             if (!st->r_frame_rate.num){
3108                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
3109                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
3110                     st->r_frame_rate.num = st->codec->time_base.den;
3111                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
3112                 }else{
3113                     st->r_frame_rate.num = st->time_base.den;
3114                     st->r_frame_rate.den = st->time_base.num;
3115                 }
3116             }
3117         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
3118             if(!st->codec->bits_per_coded_sample)
3119                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
3120             // set stream disposition based on audio service type
3121             switch (st->codec->audio_service_type) {
3122             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
3123                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
3124             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
3125                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
3126             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
3127                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
3128             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
3129                 st->disposition = AV_DISPOSITION_COMMENT;          break;
3130             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
3131                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
3132             }
3133         }
3134     }
3135
3136     if(ic->probesize)
3137     estimate_timings(ic, old_offset);
3138
3139     if (ret >= 0 && ic->nb_streams)
3140         ret = -1; /* we could not have all the codec parameters before EOF */
3141     for(i=0;i<ic->nb_streams;i++) {
3142         const char *errmsg;
3143         st = ic->streams[i];
3144         if (!has_codec_parameters(st, &errmsg)) {
3145             char buf[256];
3146             avcodec_string(buf, sizeof(buf), st->codec, 0);
3147             av_log(ic, AV_LOG_WARNING,
3148                    "Could not find codec parameters for stream %d (%s): %s\n"
3149                    "Consider increasing the value for the 'analyzeduration' and 'probesize' options\n",
3150                    i, buf, errmsg);
3151         } else {
3152             ret = 0;
3153         }
3154     }
3155
3156     compute_chapters_end(ic);
3157
3158  find_stream_info_err:
3159     for (i=0; i < ic->nb_streams; i++) {
3160         st = ic->streams[i];
3161         if (ic->streams[i]->codec && ic->streams[i]->codec->codec_type != AVMEDIA_TYPE_AUDIO)
3162             ic->streams[i]->codec->thread_count = 0;
3163         if (st->info)
3164             av_freep(&st->info->duration_error);
3165         av_freep(&ic->streams[i]->info);
3166     }
3167     if(ic->pb)
3168         av_log(ic, AV_LOG_DEBUG, "After avformat_find_stream_info() pos: %"PRId64" bytes read:%"PRId64" seeks:%d frames:%d\n",
3169                avio_tell(ic->pb), ic->pb->bytes_read, ic->pb->seek_count, count);
3170     return ret;
3171 }
3172
3173 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
3174 {
3175     int i, j;
3176
3177     for (i = 0; i < ic->nb_programs; i++) {
3178         if (ic->programs[i] == last) {
3179             last = NULL;
3180         } else {
3181             if (!last)
3182                 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
3183                     if (ic->programs[i]->stream_index[j] == s)
3184                         return ic->programs[i];
3185         }
3186     }
3187     return NULL;
3188 }
3189
3190 int av_find_best_stream(AVFormatContext *ic,
3191                         enum AVMediaType type,
3192                         int wanted_stream_nb,
3193                         int related_stream,
3194                         AVCodec **decoder_ret,
3195                         int flags)
3196 {
3197     int i, nb_streams = ic->nb_streams;
3198     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1, best_bitrate = -1, best_multiframe = -1, count, bitrate, multiframe;
3199     unsigned *program = NULL;
3200     AVCodec *decoder = NULL, *best_decoder = NULL;
3201
3202     if (related_stream >= 0 && wanted_stream_nb < 0) {
3203         AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
3204         if (p) {
3205             program = p->stream_index;
3206             nb_streams = p->nb_stream_indexes;
3207         }
3208     }
3209     for (i = 0; i < nb_streams; i++) {
3210         int real_stream_index = program ? program[i] : i;
3211         AVStream *st = ic->streams[real_stream_index];
3212         AVCodecContext *avctx = st->codec;
3213         if (avctx->codec_type != type)
3214             continue;
3215         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
3216             continue;
3217         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
3218             continue;
3219         if (decoder_ret) {
3220             decoder = find_decoder(ic, st, st->codec->codec_id);
3221             if (!decoder) {
3222                 if (ret < 0)
3223                     ret = AVERROR_DECODER_NOT_FOUND;
3224                 continue;
3225             }
3226         }
3227         count = st->codec_info_nb_frames;
3228         bitrate = avctx->bit_rate;
3229         multiframe = FFMIN(5, count);
3230         if ((best_multiframe >  multiframe) ||
3231             (best_multiframe == multiframe && best_bitrate >  bitrate) ||
3232             (best_multiframe == multiframe && best_bitrate == bitrate && best_count >= count))
3233             continue;
3234         best_count = count;
3235         best_bitrate = bitrate;
3236         best_multiframe = multiframe;
3237         ret = real_stream_index;
3238         best_decoder = decoder;
3239         if (program && i == nb_streams - 1 && ret < 0) {
3240             program = NULL;
3241             nb_streams = ic->nb_streams;
3242             i = 0; /* no related stream found, try again with everything */
3243         }
3244     }
3245     if (decoder_ret)
3246         *decoder_ret = best_decoder;
3247     return ret;
3248 }
3249
3250 /*******************************************************/
3251
3252 int av_read_play(AVFormatContext *s)
3253 {
3254     if (s->iformat->read_play)
3255         return s->iformat->read_play(s);
3256     if (s->pb)
3257         return avio_pause(s->pb, 0);
3258     return AVERROR(ENOSYS);
3259 }
3260
3261 int av_read_pause(AVFormatContext *s)
3262 {
3263     if (s->iformat->read_pause)
3264         return s->iformat->read_pause(s);
3265     if (s->pb)
3266         return avio_pause(s->pb, 1);
3267     return AVERROR(ENOSYS);
3268 }
3269
3270 void ff_free_stream(AVFormatContext *s, AVStream *st){
3271     av_assert0(s->nb_streams>0);
3272     av_assert0(s->streams[ s->nb_streams-1 ] == st);
3273
3274     if (st->parser) {
3275         av_parser_close(st->parser);
3276     }
3277     if (st->attached_pic.data)
3278         av_free_packet(&st->attached_pic);
3279     av_dict_free(&st->metadata);
3280     av_freep(&st->probe_data.buf);
3281     av_freep(&st->index_entries);
3282     av_freep(&st->codec->extradata);
3283     av_freep(&st->codec->subtitle_header);
3284     av_freep(&st->codec);
3285     av_freep(&st->priv_data);
3286     if (st->info)
3287         av_freep(&st->info->duration_error);
3288     av_freep(&st->info);
3289     av_freep(&s->streams[ --s->nb_streams ]);
3290 }
3291
3292 void avformat_free_context(AVFormatContext *s)
3293 {
3294     int i;
3295
3296     if (!s)
3297         return;
3298
3299     av_opt_free(s);
3300     if (s->iformat && s->iformat->priv_class && s->priv_data)
3301         av_opt_free(s->priv_data);
3302
3303     for(i=s->nb_streams-1; i>=0; i--) {
3304         ff_free_stream(s, s->streams[i]);
3305     }
3306     for(i=s->nb_programs-1; i>=0; i--) {
3307         av_dict_free(&s->programs[i]->metadata);
3308         av_freep(&s->programs[i]->stream_index);
3309         av_freep(&s->programs[i]);
3310     }
3311     av_freep(&s->programs);
3312     av_freep(&s->priv_data);
3313     while(s->nb_chapters--) {
3314         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
3315         av_freep(&s->chapters[s->nb_chapters]);
3316     }
3317     av_freep(&s->chapters);
3318     av_dict_free(&s->metadata);
3319     av_freep(&s->streams);
3320     av_free(s);
3321 }
3322
3323 #if FF_API_CLOSE_INPUT_FILE
3324 void av_close_input_file(AVFormatContext *s)
3325 {
3326     avformat_close_input(&s);
3327 }
3328 #endif
3329
3330 void avformat_close_input(AVFormatContext **ps)
3331 {
3332     AVFormatContext *s;
3333     AVIOContext *pb;
3334
3335     if (!ps || !*ps)
3336         return;
3337
3338     s = *ps;
3339     pb = s->pb;
3340
3341     if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
3342         (s->flags & AVFMT_FLAG_CUSTOM_IO))
3343         pb = NULL;
3344
3345     flush_packet_queue(s);
3346
3347     if (s->iformat) {
3348         if (s->iformat->read_close)
3349             s->iformat->read_close(s);
3350     }
3351
3352     avformat_free_context(s);
3353
3354     *ps = NULL;
3355
3356     avio_close(pb);
3357 }
3358
3359 #if FF_API_NEW_STREAM
3360 AVStream *av_new_stream(AVFormatContext *s, int id)
3361 {
3362     AVStream *st = avformat_new_stream(s, NULL);
3363     if (st)
3364         st->id = id;
3365     return st;
3366 }
3367 #endif
3368
3369 AVStream *avformat_new_stream(AVFormatContext *s, const AVCodec *c)
3370 {
3371     AVStream *st;
3372     int i;
3373     AVStream **streams;
3374
3375     if (s->nb_streams >= INT_MAX/sizeof(*streams))
3376         return NULL;
3377     streams = av_realloc_array(s->streams, s->nb_streams + 1, sizeof(*streams));
3378     if (!streams)
3379         return NULL;
3380     s->streams = streams;
3381
3382     st = av_mallocz(sizeof(AVStream));
3383     if (!st)
3384         return NULL;
3385     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
3386         av_free(st);
3387         return NULL;
3388     }
3389     st->info->last_dts = AV_NOPTS_VALUE;
3390
3391     st->codec = avcodec_alloc_context3(c);
3392     if (s->iformat) {
3393         /* no default bitrate if decoding */
3394         st->codec->bit_rate = 0;
3395     }
3396     st->index = s->nb_streams;
3397     st->start_time = AV_NOPTS_VALUE;
3398     st->duration = AV_NOPTS_VALUE;
3399         /* we set the current DTS to 0 so that formats without any timestamps
3400            but durations get some timestamps, formats with some unknown
3401            timestamps have their first few packets buffered and the
3402            timestamps corrected before they are returned to the user */
3403     st->cur_dts = s->iformat ? RELATIVE_TS_BASE : 0;
3404     st->first_dts = AV_NOPTS_VALUE;
3405     st->probe_packets = MAX_PROBE_PACKETS;
3406     st->pts_wrap_reference = AV_NOPTS_VALUE;
3407     st->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3408
3409     /* default pts setting is MPEG-like */
3410     avpriv_set_pts_info(st, 33, 1, 90000);
3411     st->last_IP_pts = AV_NOPTS_VALUE;
3412     for(i=0; i<MAX_REORDER_DELAY+1; i++)
3413         st->pts_buffer[i]= AV_NOPTS_VALUE;
3414
3415     st->sample_aspect_ratio = (AVRational){0,1};
3416
3417 #if FF_API_R_FRAME_RATE
3418     st->info->last_dts      = AV_NOPTS_VALUE;
3419 #endif
3420     st->info->fps_first_dts = AV_NOPTS_VALUE;
3421     st->info->fps_last_dts  = AV_NOPTS_VALUE;
3422
3423     s->streams[s->nb_streams++] = st;
3424     return st;
3425 }
3426
3427 AVProgram *av_new_program(AVFormatContext *ac, int id)
3428 {
3429     AVProgram *program=NULL;
3430     int i;
3431
3432     av_dlog(ac, "new_program: id=0x%04x\n", id);
3433
3434     for(i=0; i<ac->nb_programs; i++)
3435         if(ac->programs[i]->id == id)
3436             program = ac->programs[i];
3437
3438     if(!program){
3439         program = av_mallocz(sizeof(AVProgram));
3440         if (!program)
3441             return NULL;
3442         dynarray_add(&ac->programs, &ac->nb_programs, program);
3443         program->discard = AVDISCARD_NONE;
3444     }
3445     program->id = id;
3446     program->pts_wrap_reference = AV_NOPTS_VALUE;
3447     program->pts_wrap_behavior = AV_PTS_WRAP_IGNORE;
3448
3449     program->start_time =
3450     program->end_time   = AV_NOPTS_VALUE;
3451
3452     return program;
3453 }
3454
3455 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
3456 {
3457     AVChapter *chapter = NULL;
3458     int i;
3459
3460     for(i=0; i<s->nb_chapters; i++)
3461         if(s->chapters[i]->id == id)
3462             chapter = s->chapters[i];
3463
3464     if(!chapter){
3465         chapter= av_mallocz(sizeof(AVChapter));
3466         if(!chapter)
3467             return NULL;
3468         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
3469     }
3470     av_dict_set(&chapter->metadata, "title", title, 0);
3471     chapter->id    = id;
3472     chapter->time_base= time_base;
3473     chapter->start = start;
3474     chapter->end   = end;
3475
3476     return chapter;
3477 }
3478
3479 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3480 {
3481     int i, j;
3482     AVProgram *program=NULL;
3483     void *tmp;
3484
3485     if (idx >= ac->nb_streams) {
3486         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3487         return;
3488     }
3489
3490     for(i=0; i<ac->nb_programs; i++){
3491         if(ac->programs[i]->id != progid)
3492             continue;
3493         program = ac->programs[i];
3494         for(j=0; j<program->nb_stream_indexes; j++)
3495             if(program->stream_index[j] == idx)
3496                 return;
3497
3498         tmp = av_realloc_array(program->stream_index, program->nb_stream_indexes+1, sizeof(unsigned int));
3499         if(!tmp)
3500             return;
3501         program->stream_index = tmp;
3502         program->stream_index[program->nb_stream_indexes++] = idx;
3503         return;
3504     }
3505 }
3506
3507 static void print_fps(double d, const char *postfix){
3508     uint64_t v= lrintf(d*100);
3509     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3510     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3511     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3512 }
3513
3514 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3515 {
3516     if(m && !(av_dict_count(m) == 1 && av_dict_get(m, "language", NULL, 0))){
3517         AVDictionaryEntry *tag=NULL;
3518
3519         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3520         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3521             if(strcmp("language", tag->key)){
3522                 const char *p = tag->value;
3523                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: ", indent, tag->key);
3524                 while(*p) {
3525                     char tmp[256];
3526                     size_t len = strcspn(p, "\x8\xa\xb\xc\xd");
3527                     av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
3528                     av_log(ctx, AV_LOG_INFO, "%s", tmp);
3529                     p += len;
3530                     if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
3531                     if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s  %-16s: ", indent, "");
3532                     if (*p) p++;
3533                 }
3534                 av_log(ctx, AV_LOG_INFO, "\n");
3535             }
3536         }
3537     }
3538 }
3539
3540 /* "user interface" functions */
3541 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3542 {
3543     char buf[256];
3544     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3545     AVStream *st = ic->streams[i];
3546     int g = av_gcd(st->time_base.num, st->time_base.den);
3547     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3548     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3549     av_log(NULL, AV_LOG_INFO, "    Stream #%d:%d", index, i);
3550     /* the pid is an important information, so we display it */
3551     /* XXX: add a generic system */
3552     if (flags & AVFMT_SHOW_IDS)
3553         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3554     if (lang)
3555         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3556     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3557     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3558     if (st->sample_aspect_ratio.num && // default
3559         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3560         AVRational display_aspect_ratio;
3561         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3562                   st->codec->width*st->sample_aspect_ratio.num,
3563                   st->codec->height*st->sample_aspect_ratio.den,
3564                   1024*1024);
3565         av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3566                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3567                  display_aspect_ratio.num, display_aspect_ratio.den);
3568     }
3569     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3570         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3571             print_fps(av_q2d(st->avg_frame_rate), "fps");
3572 #if FF_API_R_FRAME_RATE
3573         if(st->r_frame_rate.den && st->r_frame_rate.num)
3574             print_fps(av_q2d(st->r_frame_rate), "tbr");
3575 #endif
3576         if(st->time_base.den && st->time_base.num)
3577             print_fps(1/av_q2d(st->time_base), "tbn");
3578         if(st->codec->time_base.den && st->codec->time_base.num)
3579             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3580     }
3581     if (st->disposition & AV_DISPOSITION_DEFAULT)
3582         av_log(NULL, AV_LOG_INFO, " (default)");
3583     if (st->disposition & AV_DISPOSITION_DUB)
3584         av_log(NULL, AV_LOG_INFO, " (dub)");
3585     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3586         av_log(NULL, AV_LOG_INFO, " (original)");
3587     if (st->disposition & AV_DISPOSITION_COMMENT)
3588         av_log(NULL, AV_LOG_INFO, " (comment)");
3589     if (st->disposition & AV_DISPOSITION_LYRICS)
3590         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3591     if (st->disposition & AV_DISPOSITION_KARAOKE)
3592         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3593     if (st->disposition & AV_DISPOSITION_FORCED)
3594         av_log(NULL, AV_LOG_INFO, " (forced)");
3595     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3596         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3597     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3598         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3599     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3600         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3601     av_log(NULL, AV_LOG_INFO, "\n");
3602     dump_metadata(NULL, st->metadata, "    ");
3603 }
3604
3605 void av_dump_format(AVFormatContext *ic,
3606                     int index,
3607                     const char *url,
3608                     int is_output)
3609 {
3610     int i;
3611     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3612     if (ic->nb_streams && !printed)
3613         return;
3614
3615     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3616             is_output ? "Output" : "Input",
3617             index,
3618             is_output ? ic->oformat->name : ic->iformat->name,
3619             is_output ? "to" : "from", url);
3620     dump_metadata(NULL, ic->metadata, "  ");
3621     if (!is_output) {
3622         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3623         if (ic->duration != AV_NOPTS_VALUE) {
3624             int hours, mins, secs, us;
3625             int64_t duration = ic->duration + 5000;
3626             secs = duration / AV_TIME_BASE;
3627             us = duration % AV_TIME_BASE;
3628             mins = secs / 60;
3629             secs %= 60;
3630             hours = mins / 60;
3631             mins %= 60;
3632             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3633                    (100 * us) / AV_TIME_BASE);
3634         } else {
3635             av_log(NULL, AV_LOG_INFO, "N/A");
3636         }
3637         if (ic->start_time != AV_NOPTS_VALUE) {
3638             int secs, us;
3639             av_log(NULL, AV_LOG_INFO, ", start: ");
3640             secs = ic->start_time / AV_TIME_BASE;
3641             us = abs(ic->start_time % AV_TIME_BASE);
3642             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3643                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3644         }
3645         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3646         if (ic->bit_rate) {
3647             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3648         } else {
3649             av_log(NULL, AV_LOG_INFO, "N/A");
3650         }
3651         av_log(NULL, AV_LOG_INFO, "\n");
3652     }
3653     for (i = 0; i < ic->nb_chapters; i++) {
3654         AVChapter *ch = ic->chapters[i];
3655         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3656         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3657         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3658
3659         dump_metadata(NULL, ch->metadata, "    ");
3660     }
3661     if(ic->nb_programs) {
3662         int j, k, total = 0;
3663         for(j=0; j<ic->nb_programs; j++) {
3664             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3665                                                   "name", NULL, 0);
3666             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3667                    name ? name->value : "");
3668             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3669             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3670                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3671                 printed[ic->programs[j]->stream_index[k]] = 1;
3672             }
3673             total += ic->programs[j]->nb_stream_indexes;
3674         }
3675         if (total < ic->nb_streams)
3676             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3677     }
3678     for(i=0;i<ic->nb_streams;i++)
3679         if (!printed[i])
3680             dump_stream_format(ic, i, index, is_output);
3681
3682     av_free(printed);
3683 }
3684
3685 uint64_t ff_ntp_time(void)
3686 {
3687   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3688 }
3689
3690 int av_get_frame_filename(char *buf, int buf_size,
3691                           const char *path, int number)
3692 {
3693     const char *p;
3694     char *q, buf1[20], c;
3695     int nd, len, percentd_found;
3696
3697     q = buf;
3698     p = path;
3699     percentd_found = 0;
3700     for(;;) {
3701         c = *p++;
3702         if (c == '\0')
3703             break;
3704         if (c == '%') {
3705             do {
3706                 nd = 0;
3707                 while (av_isdigit(*p)) {
3708                     nd = nd * 10 + *p++ - '0';
3709                 }
3710                 c = *p++;
3711             } while (av_isdigit(c));
3712
3713             switch(c) {
3714             case '%':
3715                 goto addchar;
3716             case 'd':
3717                 if (percentd_found)
3718                     goto fail;
3719                 percentd_found = 1;
3720                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3721                 len = strlen(buf1);
3722                 if ((q - buf + len) > buf_size - 1)
3723                     goto fail;
3724                 memcpy(q, buf1, len);
3725                 q += len;
3726                 break;
3727             default:
3728                 goto fail;
3729             }
3730         } else {
3731         addchar:
3732             if ((q - buf) < buf_size - 1)
3733                 *q++ = c;
3734         }
3735     }
3736     if (!percentd_found)
3737         goto fail;
3738     *q = '\0';
3739     return 0;
3740  fail:
3741     *q = '\0';
3742     return -1;
3743 }
3744
3745 static void hex_dump_internal(void *avcl, FILE *f, int level,
3746                               const uint8_t *buf, int size)
3747 {
3748     int len, i, j, c;
3749 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3750
3751     for(i=0;i<size;i+=16) {
3752         len = size - i;
3753         if (len > 16)
3754             len = 16;
3755         PRINT("%08x ", i);
3756         for(j=0;j<16;j++) {
3757             if (j < len)
3758                 PRINT(" %02x", buf[i+j]);
3759             else
3760                 PRINT("   ");
3761         }
3762         PRINT(" ");
3763         for(j=0;j<len;j++) {
3764             c = buf[i+j];
3765             if (c < ' ' || c > '~')
3766                 c = '.';
3767             PRINT("%c", c);
3768         }
3769         PRINT("\n");
3770     }
3771 #undef PRINT
3772 }
3773
3774 void av_hex_dump(FILE *f, const uint8_t *buf, int size)
3775 {
3776     hex_dump_internal(NULL, f, 0, buf, size);
3777 }
3778
3779 void av_hex_dump_log(void *avcl, int level, const uint8_t *buf, int size)
3780 {
3781     hex_dump_internal(avcl, NULL, level, buf, size);
3782 }
3783
3784 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3785 {
3786 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3787     PRINT("stream #%d:\n", pkt->stream_index);
3788     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3789     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3790     /* DTS is _always_ valid after av_read_frame() */
3791     PRINT("  dts=");
3792     if (pkt->dts == AV_NOPTS_VALUE)
3793         PRINT("N/A");
3794     else
3795         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3796     /* PTS may not be known if B-frames are present. */
3797     PRINT("  pts=");
3798     if (pkt->pts == AV_NOPTS_VALUE)
3799         PRINT("N/A");
3800     else
3801         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3802     PRINT("\n");
3803     PRINT("  size=%d\n", pkt->size);
3804 #undef PRINT
3805     if (dump_payload)
3806         av_hex_dump(f, pkt->data, pkt->size);
3807 }
3808
3809 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3810 {
3811     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3812 }
3813
3814 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3815                       AVStream *st)
3816 {
3817     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3818 }
3819
3820 void av_url_split(char *proto, int proto_size,
3821                   char *authorization, int authorization_size,
3822                   char *hostname, int hostname_size,
3823                   int *port_ptr,
3824                   char *path, int path_size,
3825                   const char *url)
3826 {
3827     const char *p, *ls, *ls2, *at, *at2, *col, *brk;
3828
3829     if (port_ptr)               *port_ptr = -1;
3830     if (proto_size > 0)         proto[0] = 0;
3831     if (authorization_size > 0) authorization[0] = 0;
3832     if (hostname_size > 0)      hostname[0] = 0;
3833     if (path_size > 0)          path[0] = 0;
3834
3835     /* parse protocol */
3836     if ((p = strchr(url, ':'))) {
3837         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3838         p++; /* skip ':' */
3839         if (*p == '/') p++;
3840         if (*p == '/') p++;
3841     } else {
3842         /* no protocol means plain filename */
3843         av_strlcpy(path, url, path_size);
3844         return;
3845     }
3846
3847     /* separate path from hostname */
3848     ls = strchr(p, '/');
3849     ls2 = strchr(p, '?');
3850     if(!ls)
3851         ls = ls2;
3852     else if (ls && ls2)
3853         ls = FFMIN(ls, ls2);
3854     if(ls)
3855         av_strlcpy(path, ls, path_size);
3856     else
3857         ls = &p[strlen(p)]; // XXX
3858
3859     /* the rest is hostname, use that to parse auth/port */
3860     if (ls != p) {
3861         /* authorization (user[:pass]@hostname) */
3862         at2 = p;
3863         while ((at = strchr(p, '@')) && at < ls) {
3864             av_strlcpy(authorization, at2,
3865                        FFMIN(authorization_size, at + 1 - at2));
3866             p = at + 1; /* skip '@' */
3867         }
3868
3869         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3870             /* [host]:port */
3871             av_strlcpy(hostname, p + 1,
3872                        FFMIN(hostname_size, brk - p));
3873             if (brk[1] == ':' && port_ptr)
3874                 *port_ptr = atoi(brk + 2);
3875         } else if ((col = strchr(p, ':')) && col < ls) {
3876             av_strlcpy(hostname, p,
3877                        FFMIN(col + 1 - p, hostname_size));
3878             if (port_ptr) *port_ptr = atoi(col + 1);
3879         } else
3880             av_strlcpy(hostname, p,
3881                        FFMIN(ls + 1 - p, hostname_size));
3882     }
3883 }
3884
3885 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3886 {
3887     int i;
3888     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3889                                            '4', '5', '6', '7',
3890                                            '8', '9', 'A', 'B',
3891                                            'C', 'D', 'E', 'F' };
3892     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3893                                            '4', '5', '6', '7',
3894                                            '8', '9', 'a', 'b',
3895                                            'c', 'd', 'e', 'f' };
3896     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3897
3898     for(i = 0; i < s; i++) {
3899         buff[i * 2]     = hex_table[src[i] >> 4];
3900         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3901     }
3902
3903     return buff;
3904 }
3905
3906 int ff_hex_to_data(uint8_t *data, const char *p)
3907 {
3908     int c, len, v;
3909
3910     len = 0;
3911     v = 1;
3912     for (;;) {
3913         p += strspn(p, SPACE_CHARS);
3914         if (*p == '\0')
3915             break;
3916         c = av_toupper((unsigned char) *p++);
3917         if (c >= '0' && c <= '9')
3918             c = c - '0';
3919         else if (c >= 'A' && c <= 'F')
3920             c = c - 'A' + 10;
3921         else
3922             break;
3923         v = (v << 4) | c;
3924         if (v & 0x100) {
3925             if (data)
3926                 data[len] = v;
3927             len++;
3928             v = 1;
3929         }
3930     }
3931     return len;
3932 }
3933
3934 #if FF_API_SET_PTS_INFO
3935 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3936                      unsigned int pts_num, unsigned int pts_den)
3937 {
3938     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3939 }
3940 #endif
3941
3942 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3943                          unsigned int pts_num, unsigned int pts_den)
3944 {
3945     AVRational new_tb;
3946     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3947         if(new_tb.num != pts_num)
3948             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3949     }else
3950         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3951
3952     if(new_tb.num <= 0 || new_tb.den <= 0) {
3953         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase %d/%d for st:%d\n", new_tb.num, new_tb.den, s->index);
3954         return;
3955     }
3956     s->time_base = new_tb;
3957     av_codec_set_pkt_timebase(s->codec, new_tb);
3958     s->pts_wrap_bits = pts_wrap_bits;
3959 }
3960
3961 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3962                         void *context)
3963 {
3964     const char *ptr = str;
3965
3966     /* Parse key=value pairs. */
3967     for (;;) {
3968         const char *key;
3969         char *dest = NULL, *dest_end;
3970         int key_len, dest_len = 0;
3971
3972         /* Skip whitespace and potential commas. */
3973         while (*ptr && (av_isspace(*ptr) || *ptr == ','))
3974             ptr++;
3975         if (!*ptr)
3976             break;
3977
3978         key = ptr;
3979
3980         if (!(ptr = strchr(key, '=')))
3981             break;
3982         ptr++;
3983         key_len = ptr - key;
3984
3985         callback_get_buf(context, key, key_len, &dest, &dest_len);
3986         dest_end = dest + dest_len - 1;
3987
3988         if (*ptr == '\"') {
3989             ptr++;
3990             while (*ptr && *ptr != '\"') {
3991                 if (*ptr == '\\') {
3992                     if (!ptr[1])
3993                         break;
3994                     if (dest && dest < dest_end)
3995                         *dest++ = ptr[1];
3996                     ptr += 2;
3997                 } else {
3998                     if (dest && dest < dest_end)
3999                         *dest++ = *ptr;
4000                     ptr++;
4001                 }
4002             }
4003             if (*ptr == '\"')
4004                 ptr++;
4005         } else {
4006             for (; *ptr && !(av_isspace(*ptr) || *ptr == ','); ptr++)
4007                 if (dest && dest < dest_end)
4008                     *dest++ = *ptr;
4009         }
4010         if (dest)
4011             *dest = 0;
4012     }
4013 }
4014
4015 int ff_find_stream_index(AVFormatContext *s, int id)
4016 {
4017     int i;
4018     for (i = 0; i < s->nb_streams; i++) {
4019         if (s->streams[i]->id == id)
4020             return i;
4021     }
4022     return -1;
4023 }
4024
4025 int64_t ff_iso8601_to_unix_time(const char *datestr)
4026 {
4027     struct tm time1 = {0}, time2 = {0};
4028     char *ret1, *ret2;
4029     ret1 = av_small_strptime(datestr, "%Y - %m - %d %H:%M:%S", &time1);
4030     ret2 = av_small_strptime(datestr, "%Y - %m - %dT%H:%M:%S", &time2);
4031     if (ret2 && !ret1)
4032         return av_timegm(&time2);
4033     else
4034         return av_timegm(&time1);
4035 }
4036
4037 int avformat_query_codec(AVOutputFormat *ofmt, enum AVCodecID codec_id, int std_compliance)
4038 {
4039     if (ofmt) {
4040         if (ofmt->query_codec)
4041             return ofmt->query_codec(codec_id, std_compliance);
4042         else if (ofmt->codec_tag)
4043             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4044         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4045                  codec_id == ofmt->subtitle_codec)
4046             return 1;
4047     }
4048     return AVERROR_PATCHWELCOME;
4049 }
4050
4051 int avformat_network_init(void)
4052 {
4053 #if CONFIG_NETWORK
4054     int ret;
4055     ff_network_inited_globally = 1;
4056     if ((ret = ff_network_init()) < 0)
4057         return ret;
4058     ff_tls_init();
4059 #endif
4060     return 0;
4061 }
4062
4063 int avformat_network_deinit(void)
4064 {
4065 #if CONFIG_NETWORK
4066     ff_network_close();
4067     ff_tls_deinit();
4068 #endif
4069     return 0;
4070 }
4071
4072 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4073                         uint64_t channel_layout, int32_t sample_rate,
4074                         int32_t width, int32_t height)
4075 {
4076     uint32_t flags = 0;
4077     int size = 4;
4078     uint8_t *data;
4079     if (!pkt)
4080         return AVERROR(EINVAL);
4081     if (channels) {
4082         size += 4;
4083         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4084     }
4085     if (channel_layout) {
4086         size += 8;
4087         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4088     }
4089     if (sample_rate) {
4090         size += 4;
4091         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4092     }
4093     if (width || height) {
4094         size += 8;
4095         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4096     }
4097     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4098     if (!data)
4099         return AVERROR(ENOMEM);
4100     bytestream_put_le32(&data, flags);
4101     if (channels)
4102         bytestream_put_le32(&data, channels);
4103     if (channel_layout)
4104         bytestream_put_le64(&data, channel_layout);
4105     if (sample_rate)
4106         bytestream_put_le32(&data, sample_rate);
4107     if (width || height) {
4108         bytestream_put_le32(&data, width);
4109         bytestream_put_le32(&data, height);
4110     }
4111     return 0;
4112 }
4113
4114 AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
4115 {
4116     AVRational undef = {0, 1};
4117     AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
4118     AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
4119     AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
4120
4121     av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
4122                stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
4123     if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
4124         stream_sample_aspect_ratio = undef;
4125
4126     av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
4127                frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
4128     if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
4129         frame_sample_aspect_ratio = undef;
4130
4131     if (stream_sample_aspect_ratio.num)
4132         return stream_sample_aspect_ratio;
4133     else
4134         return frame_sample_aspect_ratio;
4135 }
4136
4137 AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
4138 {
4139     AVRational fr = st->r_frame_rate;
4140
4141     if (st->codec->ticks_per_frame > 1) {
4142         AVRational codec_fr = av_inv_q(st->codec->time_base);
4143         AVRational   avg_fr = st->avg_frame_rate;
4144         codec_fr.den *= st->codec->ticks_per_frame;
4145         if (   codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
4146             && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
4147             fr = codec_fr;
4148     }
4149
4150     return fr;
4151 }
4152
4153 int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
4154                                     const char *spec)
4155 {
4156     if (*spec <= '9' && *spec >= '0') /* opt:index */
4157         return strtol(spec, NULL, 0) == st->index;
4158     else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
4159              *spec == 't') { /* opt:[vasdt] */
4160         enum AVMediaType type;
4161
4162         switch (*spec++) {
4163         case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
4164         case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
4165         case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
4166         case 'd': type = AVMEDIA_TYPE_DATA;       break;
4167         case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
4168         default:  av_assert0(0);
4169         }
4170         if (type != st->codec->codec_type)
4171             return 0;
4172         if (*spec++ == ':') { /* possibly followed by :index */
4173             int i, index = strtol(spec, NULL, 0);
4174             for (i = 0; i < s->nb_streams; i++)
4175                 if (s->streams[i]->codec->codec_type == type && index-- == 0)
4176                    return i == st->index;
4177             return 0;
4178         }
4179         return 1;
4180     } else if (*spec == 'p' && *(spec + 1) == ':') {
4181         int prog_id, i, j;
4182         char *endptr;
4183         spec += 2;
4184         prog_id = strtol(spec, &endptr, 0);
4185         for (i = 0; i < s->nb_programs; i++) {
4186             if (s->programs[i]->id != prog_id)
4187                 continue;
4188
4189             if (*endptr++ == ':') {
4190                 int stream_idx = strtol(endptr, NULL, 0);
4191                 return stream_idx >= 0 &&
4192                     stream_idx < s->programs[i]->nb_stream_indexes &&
4193                     st->index == s->programs[i]->stream_index[stream_idx];
4194             }
4195
4196             for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
4197                 if (st->index == s->programs[i]->stream_index[j])
4198                     return 1;
4199         }
4200         return 0;
4201     } else if (*spec == '#') {
4202         int sid;
4203         char *endptr;
4204         sid = strtol(spec + 1, &endptr, 0);
4205         if (!*endptr)
4206             return st->id == sid;
4207     } else if (!*spec) /* empty specifier, matches everything */
4208         return 1;
4209
4210     av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
4211     return AVERROR(EINVAL);
4212 }
4213
4214 int ff_generate_avci_extradata(AVStream *st)
4215 {
4216     static const uint8_t avci100_1080p_extradata[] = {
4217         // SPS
4218         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4219         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4220         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4221         0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
4222         0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
4223         0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
4224         0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
4225         0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
4226         0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
4227         // PPS
4228         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4229         0xd0
4230     };
4231     static const uint8_t avci100_1080i_extradata[] = {
4232         // SPS
4233         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4234         0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
4235         0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
4236         0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
4237         0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
4238         0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
4239         0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
4240         0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
4241         0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
4242         0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
4243         0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
4244         // PPS
4245         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
4246         0xd0
4247     };
4248     static const uint8_t avci50_1080i_extradata[] = {
4249         // SPS
4250         0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
4251         0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
4252         0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
4253         0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
4254         0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
4255         0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
4256         0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
4257         0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
4258         0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
4259         0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
4260         0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
4261         // PPS
4262         0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
4263         0x11
4264     };
4265     static const uint8_t avci100_720p_extradata[] = {
4266         // SPS
4267         0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
4268         0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
4269         0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
4270         0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
4271         0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
4272         0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
4273         0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
4274         0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
4275         0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
4276         0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
4277         // PPS
4278         0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
4279         0x11
4280     };
4281
4282     const uint8_t *data = NULL;
4283     int size = 0;
4284
4285     if (st->codec->width == 1920) {
4286         if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
4287             data = avci100_1080p_extradata;
4288             size = sizeof(avci100_1080p_extradata);
4289         } else {
4290             data = avci100_1080i_extradata;
4291             size = sizeof(avci100_1080i_extradata);
4292         }
4293     } else if (st->codec->width == 1440) {
4294         data = avci50_1080i_extradata;
4295         size = sizeof(avci50_1080i_extradata);
4296     } else if (st->codec->width == 1280) {
4297         data = avci100_720p_extradata;
4298         size = sizeof(avci100_720p_extradata);
4299     }
4300
4301     if (!size)
4302         return 0;
4303
4304     av_freep(&st->codec->extradata);
4305     if (ff_alloc_extradata(st->codec, size))
4306         return AVERROR(ENOMEM);
4307     memcpy(st->codec->extradata, data, size);
4308
4309     return 0;
4310 }