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