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