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