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