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