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