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