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