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