Frame-based multithreading framework using pthreads
[ffmpeg:cgisbertps-ffmpeg-mt.git] / libavformat / utils.c
1 /*
2  * various utility functions for use within FFmpeg
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 #include "avformat.h"
22 #include "internal.h"
23 #include "libavcodec/internal.h"
24 #include "libavutil/opt.h"
25 #include "metadata.h"
26 #include "id3v2.h"
27 #include "libavutil/avstring.h"
28 #include "riff.h"
29 #include "audiointerleave.h"
30 #include <sys/time.h>
31 #include <time.h>
32 #include <strings.h>
33 #include <stdarg.h>
34 #if CONFIG_NETWORK
35 #include "network.h"
36 #endif
37
38 #undef NDEBUG
39 #include <assert.h>
40
41 /**
42  * @file
43  * various utility functions for use within FFmpeg
44  */
45
46 unsigned avformat_version(void)
47 {
48     return LIBAVFORMAT_VERSION_INT;
49 }
50
51 const char *avformat_configuration(void)
52 {
53     return FFMPEG_CONFIGURATION;
54 }
55
56 const char *avformat_license(void)
57 {
58 #define LICENSE_PREFIX "libavformat license: "
59     return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
60 }
61
62 /* fraction handling */
63
64 /**
65  * f = val + (num / den) + 0.5.
66  *
67  * 'num' is normalized so that it is such as 0 <= num < den.
68  *
69  * @param f fractional number
70  * @param val integer value
71  * @param num must be >= 0
72  * @param den must be >= 1
73  */
74 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
75 {
76     num += (den >> 1);
77     if (num >= den) {
78         val += num / den;
79         num = num % den;
80     }
81     f->val = val;
82     f->num = num;
83     f->den = den;
84 }
85
86 /**
87  * Fractional addition to f: f = f + (incr / f->den).
88  *
89  * @param f fractional number
90  * @param incr increment, can be positive or negative
91  */
92 static void av_frac_add(AVFrac *f, int64_t incr)
93 {
94     int64_t num, den;
95
96     num = f->num + incr;
97     den = f->den;
98     if (num < 0) {
99         f->val += num / den;
100         num = num % den;
101         if (num < 0) {
102             num += den;
103             f->val--;
104         }
105     } else if (num >= den) {
106         f->val += num / den;
107         num = num % den;
108     }
109     f->num = num;
110 }
111
112 /** head of registered input format linked list */
113 #if !FF_API_FIRST_FORMAT
114 static
115 #endif
116 AVInputFormat *first_iformat = NULL;
117 /** head of registered output format linked list */
118 #if !FF_API_FIRST_FORMAT
119 static
120 #endif
121 AVOutputFormat *first_oformat = NULL;
122
123 AVInputFormat  *av_iformat_next(AVInputFormat  *f)
124 {
125     if(f) return f->next;
126     else  return first_iformat;
127 }
128
129 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
130 {
131     if(f) return f->next;
132     else  return first_oformat;
133 }
134
135 void av_register_input_format(AVInputFormat *format)
136 {
137     AVInputFormat **p;
138     p = &first_iformat;
139     while (*p != NULL) p = &(*p)->next;
140     *p = format;
141     format->next = NULL;
142 }
143
144 void av_register_output_format(AVOutputFormat *format)
145 {
146     AVOutputFormat **p;
147     p = &first_oformat;
148     while (*p != NULL) p = &(*p)->next;
149     *p = format;
150     format->next = NULL;
151 }
152
153 int av_match_ext(const char *filename, const char *extensions)
154 {
155     const char *ext, *p;
156     char ext1[32], *q;
157
158     if(!filename)
159         return 0;
160
161     ext = strrchr(filename, '.');
162     if (ext) {
163         ext++;
164         p = extensions;
165         for(;;) {
166             q = ext1;
167             while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
168                 *q++ = *p++;
169             *q = '\0';
170             if (!strcasecmp(ext1, ext))
171                 return 1;
172             if (*p == '\0')
173                 break;
174             p++;
175         }
176     }
177     return 0;
178 }
179
180 static int match_format(const char *name, const char *names)
181 {
182     const char *p;
183     int len, namelen;
184
185     if (!name || !names)
186         return 0;
187
188     namelen = strlen(name);
189     while ((p = strchr(names, ','))) {
190         len = FFMAX(p - names, namelen);
191         if (!strncasecmp(name, names, len))
192             return 1;
193         names = p+1;
194     }
195     return !strcasecmp(name, names);
196 }
197
198 #if FF_API_GUESS_FORMAT
199 AVOutputFormat *guess_format(const char *short_name, const char *filename,
200                              const char *mime_type)
201 {
202     return av_guess_format(short_name, filename, mime_type);
203 }
204 #endif
205
206 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
207                                 const char *mime_type)
208 {
209     AVOutputFormat *fmt = NULL, *fmt_found;
210     int score_max, score;
211
212     /* specific test for image sequences */
213 #if CONFIG_IMAGE2_MUXER
214     if (!short_name && filename &&
215         av_filename_number_test(filename) &&
216         av_guess_image2_codec(filename) != CODEC_ID_NONE) {
217         return av_guess_format("image2", NULL, NULL);
218     }
219 #endif
220     /* Find the proper file type. */
221     fmt_found = NULL;
222     score_max = 0;
223     while ((fmt = av_oformat_next(fmt))) {
224         score = 0;
225         if (fmt->name && short_name && !strcmp(fmt->name, short_name))
226             score += 100;
227         if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
228             score += 10;
229         if (filename && fmt->extensions &&
230             av_match_ext(filename, fmt->extensions)) {
231             score += 5;
232         }
233         if (score > score_max) {
234             score_max = score;
235             fmt_found = fmt;
236         }
237     }
238     return fmt_found;
239 }
240
241 #if FF_API_GUESS_FORMAT
242 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
243                              const char *mime_type)
244 {
245     AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
246
247     if (fmt) {
248         AVOutputFormat *stream_fmt;
249         char stream_format_name[64];
250
251         snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
252         stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
253
254         if (stream_fmt)
255             fmt = stream_fmt;
256     }
257
258     return fmt;
259 }
260 #endif
261
262 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
263                             const char *filename, const char *mime_type, enum AVMediaType type){
264     if(type == AVMEDIA_TYPE_VIDEO){
265         enum CodecID codec_id= CODEC_ID_NONE;
266
267 #if CONFIG_IMAGE2_MUXER
268         if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
269             codec_id= av_guess_image2_codec(filename);
270         }
271 #endif
272         if(codec_id == CODEC_ID_NONE)
273             codec_id= fmt->video_codec;
274         return codec_id;
275     }else if(type == AVMEDIA_TYPE_AUDIO)
276         return fmt->audio_codec;
277     else if (type == AVMEDIA_TYPE_SUBTITLE)
278         return fmt->subtitle_codec;
279     else
280         return CODEC_ID_NONE;
281 }
282
283 AVInputFormat *av_find_input_format(const char *short_name)
284 {
285     AVInputFormat *fmt = NULL;
286     while ((fmt = av_iformat_next(fmt))) {
287         if (match_format(short_name, fmt->name))
288             return fmt;
289     }
290     return NULL;
291 }
292
293 #if FF_API_SYMVER && CONFIG_SHARED && HAVE_SYMVER
294 FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
295 {
296     av_destruct_packet_nofree(pkt);
297 }
298
299 FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
300 {
301     av_destruct_packet(pkt);
302 }
303
304 FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
305 {
306     return av_new_packet(pkt, size);
307 }
308
309 FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
310 {
311     return av_dup_packet(pkt);
312 }
313
314 FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
315 {
316     av_free_packet(pkt);
317 }
318
319 FF_SYMVER(void, av_init_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
320 {
321     av_log(NULL, AV_LOG_WARNING, "Diverting av_*_packet function calls to libavcodec. Recompile to improve performance\n");
322     av_init_packet(pkt);
323 }
324 #endif
325
326 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
327 {
328     int ret= av_new_packet(pkt, size);
329
330     if(ret<0)
331         return ret;
332
333     pkt->pos= url_ftell(s);
334
335     ret= get_buffer(s, pkt->data, size);
336     if(ret<=0)
337         av_free_packet(pkt);
338     else
339         av_shrink_packet(pkt, ret);
340
341     return ret;
342 }
343
344 int av_append_packet(ByteIOContext *s, AVPacket *pkt, int size)
345 {
346     int ret;
347     int old_size;
348     if (!pkt->size)
349         return av_get_packet(s, pkt, size);
350     old_size = pkt->size;
351     ret = av_grow_packet(pkt, size);
352     if (ret < 0)
353         return ret;
354     ret = get_buffer(s, pkt->data + old_size, size);
355     av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
356     return ret;
357 }
358
359
360 int av_filename_number_test(const char *filename)
361 {
362     char buf[1024];
363     return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
364 }
365
366 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
367 {
368     AVProbeData lpd = *pd;
369     AVInputFormat *fmt1 = NULL, *fmt;
370     int score;
371
372     if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
373         int id3len = ff_id3v2_tag_len(lpd.buf);
374         if (lpd.buf_size > id3len + 16) {
375             lpd.buf += id3len;
376             lpd.buf_size -= id3len;
377         }
378     }
379
380     fmt = NULL;
381     while ((fmt1 = av_iformat_next(fmt1))) {
382         if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
383             continue;
384         score = 0;
385         if (fmt1->read_probe) {
386             score = fmt1->read_probe(&lpd);
387         } else if (fmt1->extensions) {
388             if (av_match_ext(lpd.filename, fmt1->extensions)) {
389                 score = 50;
390             }
391         }
392         if (score > *score_max) {
393             *score_max = score;
394             fmt = fmt1;
395         }else if (score == *score_max)
396             fmt = NULL;
397     }
398     return fmt;
399 }
400
401 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
402     int score=0;
403     return av_probe_input_format2(pd, is_opened, &score);
404 }
405
406 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
407 {
408     static const struct {
409         const char *name; enum CodecID id; enum AVMediaType type;
410     } fmt_id_type[] = {
411         { "aac"      , CODEC_ID_AAC       , AVMEDIA_TYPE_AUDIO },
412         { "ac3"      , CODEC_ID_AC3       , AVMEDIA_TYPE_AUDIO },
413         { "dts"      , CODEC_ID_DTS       , AVMEDIA_TYPE_AUDIO },
414         { "eac3"     , CODEC_ID_EAC3      , AVMEDIA_TYPE_AUDIO },
415         { "h264"     , CODEC_ID_H264      , AVMEDIA_TYPE_VIDEO },
416         { "m4v"      , CODEC_ID_MPEG4     , AVMEDIA_TYPE_VIDEO },
417         { "mp3"      , CODEC_ID_MP3       , AVMEDIA_TYPE_AUDIO },
418         { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
419         { 0 }
420     };
421     AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
422
423     if (fmt) {
424         int i;
425         av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
426                pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
427         for (i = 0; fmt_id_type[i].name; i++) {
428             if (!strcmp(fmt->name, fmt_id_type[i].name)) {
429                 st->codec->codec_id   = fmt_id_type[i].id;
430                 st->codec->codec_type = fmt_id_type[i].type;
431                 break;
432             }
433         }
434     }
435     return !!fmt;
436 }
437
438 /************************************************************/
439 /* input media file */
440
441 /**
442  * Open a media file from an IO stream. 'fmt' must be specified.
443  */
444 int av_open_input_stream(AVFormatContext **ic_ptr,
445                          ByteIOContext *pb, const char *filename,
446                          AVInputFormat *fmt, AVFormatParameters *ap)
447 {
448     int err;
449     AVFormatContext *ic;
450     AVFormatParameters default_ap;
451
452     if(!ap){
453         ap=&default_ap;
454         memset(ap, 0, sizeof(default_ap));
455     }
456
457     if(!ap->prealloced_context)
458         ic = avformat_alloc_context();
459     else
460         ic = *ic_ptr;
461     if (!ic) {
462         err = AVERROR(ENOMEM);
463         goto fail;
464     }
465     ic->iformat = fmt;
466     ic->pb = pb;
467     ic->duration = AV_NOPTS_VALUE;
468     ic->start_time = AV_NOPTS_VALUE;
469     av_strlcpy(ic->filename, filename, sizeof(ic->filename));
470
471     /* allocate private data */
472     if (fmt->priv_data_size > 0) {
473         ic->priv_data = av_mallocz(fmt->priv_data_size);
474         if (!ic->priv_data) {
475             err = AVERROR(ENOMEM);
476             goto fail;
477         }
478     } else {
479         ic->priv_data = NULL;
480     }
481
482     // e.g. AVFMT_NOFILE formats will not have a ByteIOContext
483     if (ic->pb)
484         ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
485
486     if (ic->iformat->read_header) {
487         err = ic->iformat->read_header(ic, ap);
488         if (err < 0)
489             goto fail;
490     }
491
492     if (pb && !ic->data_offset)
493         ic->data_offset = url_ftell(ic->pb);
494
495 #if FF_API_OLD_METADATA
496     ff_metadata_demux_compat(ic);
497 #endif
498
499     ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
500
501     *ic_ptr = ic;
502     return 0;
503  fail:
504     if (ic) {
505         int i;
506         av_freep(&ic->priv_data);
507         for(i=0;i<ic->nb_streams;i++) {
508             AVStream *st = ic->streams[i];
509             if (st) {
510                 av_free(st->priv_data);
511                 av_free(st->codec->extradata);
512                 av_free(st->codec);
513                 av_free(st->info);
514             }
515             av_free(st);
516         }
517     }
518     av_free(ic);
519     *ic_ptr = NULL;
520     return err;
521 }
522
523 /** size of probe buffer, for guessing file type from file contents */
524 #define PROBE_BUF_MIN 2048
525 #define PROBE_BUF_MAX (1<<20)
526
527 int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
528                           const char *filename, void *logctx,
529                           unsigned int offset, unsigned int max_probe_size)
530 {
531     AVProbeData pd = { filename ? filename : "", NULL, -offset };
532     unsigned char *buf = NULL;
533     int ret = 0, probe_size;
534
535     if (!max_probe_size) {
536         max_probe_size = PROBE_BUF_MAX;
537     } else if (max_probe_size > PROBE_BUF_MAX) {
538         max_probe_size = PROBE_BUF_MAX;
539     } else if (max_probe_size < PROBE_BUF_MIN) {
540         return AVERROR(EINVAL);
541     }
542
543     if (offset >= max_probe_size) {
544         return AVERROR(EINVAL);
545     }
546
547     for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
548         probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
549         int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
550         int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
551
552         if (probe_size < offset) {
553             continue;
554         }
555
556         /* read probe data */
557         buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
558         if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
559             /* fail if error was not end of file, otherwise, lower score */
560             if (ret != AVERROR_EOF) {
561                 av_free(buf);
562                 return ret;
563             }
564             score = 0;
565             ret = 0;            /* error was end of file, nothing read */
566         }
567         pd.buf_size += ret;
568         pd.buf = &buf[offset];
569
570         memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
571
572         /* guess file format */
573         *fmt = av_probe_input_format2(&pd, 1, &score);
574         if(*fmt){
575             if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
576                 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
577             }else
578                 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
579         }
580     }
581
582     if (!*fmt) {
583         av_free(buf);
584         return AVERROR_INVALIDDATA;
585     }
586
587     /* rewind. reuse probe buffer to avoid seeking */
588     if ((ret = ff_rewind_with_probe_data(*pb, buf, pd.buf_size)) < 0)
589         av_free(buf);
590
591     return ret;
592 }
593
594 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
595                        AVInputFormat *fmt,
596                        int buf_size,
597                        AVFormatParameters *ap)
598 {
599     int err;
600     AVProbeData probe_data, *pd = &probe_data;
601     ByteIOContext *pb = NULL;
602     void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
603
604     pd->filename = "";
605     if (filename)
606         pd->filename = filename;
607     pd->buf = NULL;
608     pd->buf_size = 0;
609
610     if (!fmt) {
611         /* guess format if no file can be opened */
612         fmt = av_probe_input_format(pd, 0);
613     }
614
615     /* Do not open file if the format does not need it. XXX: specific
616        hack needed to handle RTSP/TCP */
617     if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
618         /* if no file needed do not try to open one */
619         if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
620             goto fail;
621         }
622         if (buf_size > 0) {
623             url_setbufsize(pb, buf_size);
624         }
625         if (!fmt && (err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
626             goto fail;
627         }
628     }
629
630     /* if still no format found, error */
631     if (!fmt) {
632         err = AVERROR_INVALIDDATA;
633         goto fail;
634     }
635
636     /* check filename in case an image number is expected */
637     if (fmt->flags & AVFMT_NEEDNUMBER) {
638         if (!av_filename_number_test(filename)) {
639             err = AVERROR_NUMEXPECTED;
640             goto fail;
641         }
642     }
643     err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
644     if (err)
645         goto fail;
646     return 0;
647  fail:
648     av_freep(&pd->buf);
649     if (pb)
650         url_fclose(pb);
651     if (ap && ap->prealloced_context)
652         av_free(*ic_ptr);
653     *ic_ptr = NULL;
654     return err;
655
656 }
657
658 /*******************************************************/
659
660 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
661                                AVPacketList **plast_pktl){
662     AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
663     if (!pktl)
664         return NULL;
665
666     if (*packet_buffer)
667         (*plast_pktl)->next = pktl;
668     else
669         *packet_buffer = pktl;
670
671     /* add the packet in the buffered packet list */
672     *plast_pktl = pktl;
673     pktl->pkt= *pkt;
674     return &pktl->pkt;
675 }
676
677 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
678 {
679     int ret, i;
680     AVStream *st;
681
682     for(;;){
683         AVPacketList *pktl = s->raw_packet_buffer;
684
685         if (pktl) {
686             *pkt = pktl->pkt;
687             if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
688                !s->streams[pkt->stream_index]->probe_packets ||
689                s->raw_packet_buffer_remaining_size < pkt->size){
690                 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
691                 av_freep(&pd->buf);
692                 pd->buf_size = 0;
693                 s->raw_packet_buffer = pktl->next;
694                 s->raw_packet_buffer_remaining_size += pkt->size;
695                 av_free(pktl);
696                 return 0;
697             }
698         }
699
700         av_init_packet(pkt);
701         ret= s->iformat->read_packet(s, pkt);
702         if (ret < 0) {
703             if (!pktl || ret == AVERROR(EAGAIN))
704                 return ret;
705             for (i = 0; i < s->nb_streams; i++)
706                 s->streams[i]->probe_packets = 0;
707             continue;
708         }
709         st= s->streams[pkt->stream_index];
710
711         switch(st->codec->codec_type){
712         case AVMEDIA_TYPE_VIDEO:
713             if(s->video_codec_id)   st->codec->codec_id= s->video_codec_id;
714             break;
715         case AVMEDIA_TYPE_AUDIO:
716             if(s->audio_codec_id)   st->codec->codec_id= s->audio_codec_id;
717             break;
718         case AVMEDIA_TYPE_SUBTITLE:
719             if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
720             break;
721         }
722
723         if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
724                      !st->probe_packets))
725             return ret;
726
727         add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
728         s->raw_packet_buffer_remaining_size -= pkt->size;
729
730         if(st->codec->codec_id == CODEC_ID_PROBE){
731             AVProbeData *pd = &st->probe_data;
732             av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
733             --st->probe_packets;
734
735             pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
736             memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
737             pd->buf_size += pkt->size;
738             memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
739
740             if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
741                 //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
742                 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
743                 if(st->codec->codec_id != CODEC_ID_PROBE){
744                     pd->buf_size=0;
745                     av_freep(&pd->buf);
746                     av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
747                 }
748             }
749         }
750     }
751 }
752
753 /**********************************************************/
754
755 /**
756  * Get the number of samples of an audio frame. Return -1 on error.
757  */
758 static int get_audio_frame_size(AVCodecContext *enc, int size)
759 {
760     int frame_size;
761
762     if(enc->codec_id == CODEC_ID_VORBIS)
763         return -1;
764
765     if (enc->frame_size <= 1) {
766         int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
767
768         if (bits_per_sample) {
769             if (enc->channels == 0)
770                 return -1;
771             frame_size = (size << 3) / (bits_per_sample * enc->channels);
772         } else {
773             /* used for example by ADPCM codecs */
774             if (enc->bit_rate == 0)
775                 return -1;
776             frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
777         }
778     } else {
779         frame_size = enc->frame_size;
780     }
781     return frame_size;
782 }
783
784
785 /**
786  * Return the frame duration in seconds. Return 0 if not available.
787  */
788 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
789                                    AVCodecParserContext *pc, AVPacket *pkt)
790 {
791     int frame_size;
792
793     *pnum = 0;
794     *pden = 0;
795     switch(st->codec->codec_type) {
796     case AVMEDIA_TYPE_VIDEO:
797         if(st->time_base.num*1000LL > st->time_base.den){
798             *pnum = st->time_base.num;
799             *pden = st->time_base.den;
800         }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
801             *pnum = st->codec->time_base.num;
802             *pden = st->codec->time_base.den;
803             if (pc && pc->repeat_pict) {
804                 *pnum = (*pnum) * (1 + pc->repeat_pict);
805             }
806             //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
807             //Thus if we have no parser in such case leave duration undefined.
808             if(st->codec->ticks_per_frame>1 && !pc){
809                 *pnum = *pden = 0;
810             }
811         }
812         break;
813     case AVMEDIA_TYPE_AUDIO:
814         frame_size = get_audio_frame_size(st->codec, pkt->size);
815         if (frame_size <= 0 || st->codec->sample_rate <= 0)
816             break;
817         *pnum = frame_size;
818         *pden = st->codec->sample_rate;
819         break;
820     default:
821         break;
822     }
823 }
824
825 static int is_intra_only(AVCodecContext *enc){
826     if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
827         return 1;
828     }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
829         switch(enc->codec_id){
830         case CODEC_ID_MJPEG:
831         case CODEC_ID_MJPEGB:
832         case CODEC_ID_LJPEG:
833         case CODEC_ID_RAWVIDEO:
834         case CODEC_ID_DVVIDEO:
835         case CODEC_ID_HUFFYUV:
836         case CODEC_ID_FFVHUFF:
837         case CODEC_ID_ASV1:
838         case CODEC_ID_ASV2:
839         case CODEC_ID_VCR1:
840         case CODEC_ID_DNXHD:
841         case CODEC_ID_JPEG2000:
842             return 1;
843         default: break;
844         }
845     }
846     return 0;
847 }
848
849 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
850                                       int64_t dts, int64_t pts)
851 {
852     AVStream *st= s->streams[stream_index];
853     AVPacketList *pktl= s->packet_buffer;
854
855     if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
856         return;
857
858     st->first_dts= dts - st->cur_dts;
859     st->cur_dts= dts;
860
861     for(; pktl; pktl= pktl->next){
862         if(pktl->pkt.stream_index != stream_index)
863             continue;
864         //FIXME think more about this check
865         if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
866             pktl->pkt.pts += st->first_dts;
867
868         if(pktl->pkt.dts != AV_NOPTS_VALUE)
869             pktl->pkt.dts += st->first_dts;
870
871         if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
872             st->start_time= pktl->pkt.pts;
873     }
874     if (st->start_time == AV_NOPTS_VALUE)
875         st->start_time = pts;
876 }
877
878 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
879 {
880     AVPacketList *pktl= s->packet_buffer;
881     int64_t cur_dts= 0;
882
883     if(st->first_dts != AV_NOPTS_VALUE){
884         cur_dts= st->first_dts;
885         for(; pktl; pktl= pktl->next){
886             if(pktl->pkt.stream_index == pkt->stream_index){
887                 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
888                     break;
889                 cur_dts -= pkt->duration;
890             }
891         }
892         pktl= s->packet_buffer;
893         st->first_dts = cur_dts;
894     }else if(st->cur_dts)
895         return;
896
897     for(; pktl; pktl= pktl->next){
898         if(pktl->pkt.stream_index != pkt->stream_index)
899             continue;
900         if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
901            && !pktl->pkt.duration){
902             pktl->pkt.dts= cur_dts;
903             if(!st->codec->has_b_frames)
904                 pktl->pkt.pts= cur_dts;
905             cur_dts += pkt->duration;
906             pktl->pkt.duration= pkt->duration;
907         }else
908             break;
909     }
910     if(st->first_dts == AV_NOPTS_VALUE)
911         st->cur_dts= cur_dts;
912 }
913
914 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
915                                AVCodecParserContext *pc, AVPacket *pkt)
916 {
917     int num, den, presentation_delayed, delay, i;
918     int64_t offset;
919
920     if (s->flags & AVFMT_FLAG_NOFILLIN)
921         return;
922
923     if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
924         pkt->dts= AV_NOPTS_VALUE;
925
926     if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
927         //FIXME Set low_delay = 0 when has_b_frames = 1
928         st->codec->has_b_frames = 1;
929
930     /* do we have a video B-frame ? */
931     delay= st->codec->has_b_frames;
932     presentation_delayed = 0;
933
934     // ignore delay caused by frame threading so that the mpeg2-without-dts
935     // warning will not trigger
936     if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
937         delay -= st->codec->thread_count-1;
938
939     /* XXX: need has_b_frame, but cannot get it if the codec is
940         not initialized */
941     if (delay &&
942         pc && pc->pict_type != FF_B_TYPE)
943         presentation_delayed = 1;
944
945     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
946        /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
947         pkt->dts -= 1LL<<st->pts_wrap_bits;
948     }
949
950     // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
951     // we take the conservative approach and discard both
952     // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
953     if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
954         av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
955         pkt->dts= pkt->pts= AV_NOPTS_VALUE;
956     }
957
958     if (pkt->duration == 0) {
959         compute_frame_duration(&num, &den, st, pc, pkt);
960         if (den && num) {
961             pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
962
963             if(pkt->duration != 0 && s->packet_buffer)
964                 update_initial_durations(s, st, pkt);
965         }
966     }
967
968     /* correct timestamps with byte offset if demuxers only have timestamps
969        on packet boundaries */
970     if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
971         /* this will estimate bitrate based on this frame's duration and size */
972         offset = av_rescale(pc->offset, pkt->duration, pkt->size);
973         if(pkt->pts != AV_NOPTS_VALUE)
974             pkt->pts += offset;
975         if(pkt->dts != AV_NOPTS_VALUE)
976             pkt->dts += offset;
977     }
978
979     if (pc && pc->dts_sync_point >= 0) {
980         // we have synchronization info from the parser
981         int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
982         if (den > 0) {
983             int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
984             if (pkt->dts != AV_NOPTS_VALUE) {
985                 // got DTS from the stream, update reference timestamp
986                 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
987                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
988             } else if (st->reference_dts != AV_NOPTS_VALUE) {
989                 // compute DTS based on reference timestamp
990                 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
991                 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
992             }
993             if (pc->dts_sync_point > 0)
994                 st->reference_dts = pkt->dts; // new reference
995         }
996     }
997
998     /* This may be redundant, but it should not hurt. */
999     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1000         presentation_delayed = 1;
1001
1002 //    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);
1003     /* interpolate PTS and DTS if they are not present */
1004     //We skip H264 currently because delay and has_b_frames are not reliably set
1005     if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1006         if (presentation_delayed) {
1007             /* DTS = decompression timestamp */
1008             /* PTS = presentation timestamp */
1009             if (pkt->dts == AV_NOPTS_VALUE)
1010                 pkt->dts = st->last_IP_pts;
1011             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1012             if (pkt->dts == AV_NOPTS_VALUE)
1013                 pkt->dts = st->cur_dts;
1014
1015             /* this is tricky: the dts must be incremented by the duration
1016             of the frame we are displaying, i.e. the last I- or P-frame */
1017             if (st->last_IP_duration == 0)
1018                 st->last_IP_duration = pkt->duration;
1019             if(pkt->dts != AV_NOPTS_VALUE)
1020                 st->cur_dts = pkt->dts + st->last_IP_duration;
1021             st->last_IP_duration  = pkt->duration;
1022             st->last_IP_pts= pkt->pts;
1023             /* cannot compute PTS if not present (we can compute it only
1024             by knowing the future */
1025         } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1026             if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1027                 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1028                 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1029                 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1030                     pkt->pts += pkt->duration;
1031     //                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);
1032                 }
1033             }
1034
1035             /* presentation is not delayed : PTS and DTS are the same */
1036             if(pkt->pts == AV_NOPTS_VALUE)
1037                 pkt->pts = pkt->dts;
1038             update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1039             if(pkt->pts == AV_NOPTS_VALUE)
1040                 pkt->pts = st->cur_dts;
1041             pkt->dts = pkt->pts;
1042             if(pkt->pts != AV_NOPTS_VALUE)
1043                 st->cur_dts = pkt->pts + pkt->duration;
1044         }
1045     }
1046
1047     if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1048         st->pts_buffer[0]= pkt->pts;
1049         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1050             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1051         if(pkt->dts == AV_NOPTS_VALUE)
1052             pkt->dts= st->pts_buffer[0];
1053         if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1054             update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1055         }
1056         if(pkt->dts > st->cur_dts)
1057             st->cur_dts = pkt->dts;
1058     }
1059
1060 //    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);
1061
1062     /* update flags */
1063     if(is_intra_only(st->codec))
1064         pkt->flags |= AV_PKT_FLAG_KEY;
1065     else if (pc) {
1066         pkt->flags = 0;
1067         /* keyframe computation */
1068         if (pc->key_frame == 1)
1069             pkt->flags |= AV_PKT_FLAG_KEY;
1070         else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1071             pkt->flags |= AV_PKT_FLAG_KEY;
1072     }
1073     if (pc)
1074         pkt->convergence_duration = pc->convergence_duration;
1075 }
1076
1077
1078 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1079 {
1080     AVStream *st;
1081     int len, ret, i;
1082
1083     av_init_packet(pkt);
1084
1085     for(;;) {
1086         /* select current input stream component */
1087         st = s->cur_st;
1088         if (st) {
1089             if (!st->need_parsing || !st->parser) {
1090                 /* no parsing needed: we just output the packet as is */
1091                 /* raw data support */
1092                 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1093                 compute_pkt_fields(s, st, NULL, pkt);
1094                 s->cur_st = NULL;
1095                 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1096                     (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1097                     ff_reduce_index(s, st->index);
1098                     av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1099                 }
1100                 break;
1101             } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1102                 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1103                                        st->cur_ptr, st->cur_len,
1104                                        st->cur_pkt.pts, st->cur_pkt.dts,
1105                                        st->cur_pkt.pos);
1106                 st->cur_pkt.pts = AV_NOPTS_VALUE;
1107                 st->cur_pkt.dts = AV_NOPTS_VALUE;
1108                 /* increment read pointer */
1109                 st->cur_ptr += len;
1110                 st->cur_len -= len;
1111
1112                 /* return packet if any */
1113                 if (pkt->size) {
1114                 got_packet:
1115                     pkt->duration = 0;
1116                     pkt->stream_index = st->index;
1117                     pkt->pts = st->parser->pts;
1118                     pkt->dts = st->parser->dts;
1119                     pkt->pos = st->parser->pos;
1120                     if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1121                         s->cur_st = NULL;
1122                         pkt->destruct= st->cur_pkt.destruct;
1123                         st->cur_pkt.destruct= NULL;
1124                         st->cur_pkt.data    = NULL;
1125                         assert(st->cur_len == 0);
1126                     }else{
1127                     pkt->destruct = NULL;
1128                     }
1129                     compute_pkt_fields(s, st, st->parser, pkt);
1130
1131                     if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1132                         ff_reduce_index(s, st->index);
1133                         av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1134                                            0, 0, AVINDEX_KEYFRAME);
1135                     }
1136
1137                     break;
1138                 }
1139             } else {
1140                 /* free packet */
1141                 av_free_packet(&st->cur_pkt);
1142                 s->cur_st = NULL;
1143             }
1144         } else {
1145             AVPacket cur_pkt;
1146             /* read next packet */
1147             ret = av_read_packet(s, &cur_pkt);
1148             if (ret < 0) {
1149                 if (ret == AVERROR(EAGAIN))
1150                     return ret;
1151                 /* return the last frames, if any */
1152                 for(i = 0; i < s->nb_streams; i++) {
1153                     st = s->streams[i];
1154                     if (st->parser && st->need_parsing) {
1155                         av_parser_parse2(st->parser, st->codec,
1156                                         &pkt->data, &pkt->size,
1157                                         NULL, 0,
1158                                         AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1159                                         AV_NOPTS_VALUE);
1160                         if (pkt->size)
1161                             goto got_packet;
1162                     }
1163                 }
1164                 /* no more packets: really terminate parsing */
1165                 return ret;
1166             }
1167             st = s->streams[cur_pkt.stream_index];
1168             st->cur_pkt= cur_pkt;
1169
1170             if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1171                st->cur_pkt.dts != AV_NOPTS_VALUE &&
1172                st->cur_pkt.pts < st->cur_pkt.dts){
1173                 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1174                     st->cur_pkt.stream_index,
1175                     st->cur_pkt.pts,
1176                     st->cur_pkt.dts,
1177                     st->cur_pkt.size);
1178 //                av_free_packet(&st->cur_pkt);
1179 //                return -1;
1180             }
1181
1182             if(s->debug & FF_FDEBUG_TS)
1183                 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1184                     st->cur_pkt.stream_index,
1185                     st->cur_pkt.pts,
1186                     st->cur_pkt.dts,
1187                     st->cur_pkt.size,
1188                     st->cur_pkt.duration,
1189                     st->cur_pkt.flags);
1190
1191             s->cur_st = st;
1192             st->cur_ptr = st->cur_pkt.data;
1193             st->cur_len = st->cur_pkt.size;
1194             if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1195                 st->parser = av_parser_init(st->codec->codec_id);
1196                 if (!st->parser) {
1197                     /* no parser available: just output the raw packets */
1198                     st->need_parsing = AVSTREAM_PARSE_NONE;
1199                 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1200                     st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1201                 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1202                     st->parser->flags |= PARSER_FLAG_ONCE;
1203                 }
1204             }
1205         }
1206     }
1207     if(s->debug & FF_FDEBUG_TS)
1208         av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1209             pkt->stream_index,
1210             pkt->pts,
1211             pkt->dts,
1212             pkt->size,
1213             pkt->duration,
1214             pkt->flags);
1215
1216     return 0;
1217 }
1218
1219 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1220 {
1221     AVPacketList *pktl;
1222     int eof=0;
1223     const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1224
1225     for(;;){
1226         pktl = s->packet_buffer;
1227         if (pktl) {
1228             AVPacket *next_pkt= &pktl->pkt;
1229
1230             if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1231                 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1232                 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1233                     if(   pktl->pkt.stream_index == next_pkt->stream_index
1234                        && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1235                        && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1236                         next_pkt->pts= pktl->pkt.dts;
1237                     }
1238                     pktl= pktl->next;
1239                 }
1240                 pktl = s->packet_buffer;
1241             }
1242
1243             if(   next_pkt->pts != AV_NOPTS_VALUE
1244                || next_pkt->dts == AV_NOPTS_VALUE
1245                || !genpts || eof){
1246                 /* read packet from packet buffer, if there is data */
1247                 *pkt = *next_pkt;
1248                 s->packet_buffer = pktl->next;
1249                 av_free(pktl);
1250                 return 0;
1251             }
1252         }
1253         if(genpts){
1254             int ret= av_read_frame_internal(s, pkt);
1255             if(ret<0){
1256                 if(pktl && ret != AVERROR(EAGAIN)){
1257                     eof=1;
1258                     continue;
1259                 }else
1260                     return ret;
1261             }
1262
1263             if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1264                                            &s->packet_buffer_end)) < 0)
1265                 return AVERROR(ENOMEM);
1266         }else{
1267             assert(!s->packet_buffer);
1268             return av_read_frame_internal(s, pkt);
1269         }
1270     }
1271 }
1272
1273 /* XXX: suppress the packet queue */
1274 static void flush_packet_queue(AVFormatContext *s)
1275 {
1276     AVPacketList *pktl;
1277
1278     for(;;) {
1279         pktl = s->packet_buffer;
1280         if (!pktl)
1281             break;
1282         s->packet_buffer = pktl->next;
1283         av_free_packet(&pktl->pkt);
1284         av_free(pktl);
1285     }
1286     while(s->raw_packet_buffer){
1287         pktl = s->raw_packet_buffer;
1288         s->raw_packet_buffer = pktl->next;
1289         av_free_packet(&pktl->pkt);
1290         av_free(pktl);
1291     }
1292     s->packet_buffer_end=
1293     s->raw_packet_buffer_end= NULL;
1294     s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1295 }
1296
1297 /*******************************************************/
1298 /* seek support */
1299
1300 int av_find_default_stream_index(AVFormatContext *s)
1301 {
1302     int first_audio_index = -1;
1303     int i;
1304     AVStream *st;
1305
1306     if (s->nb_streams <= 0)
1307         return -1;
1308     for(i = 0; i < s->nb_streams; i++) {
1309         st = s->streams[i];
1310         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1311             return i;
1312         }
1313         if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1314             first_audio_index = i;
1315     }
1316     return first_audio_index >= 0 ? first_audio_index : 0;
1317 }
1318
1319 /**
1320  * Flush the frame reader.
1321  */
1322 void ff_read_frame_flush(AVFormatContext *s)
1323 {
1324     AVStream *st;
1325     int i, j;
1326
1327     flush_packet_queue(s);
1328
1329     s->cur_st = NULL;
1330
1331     /* for each stream, reset read state */
1332     for(i = 0; i < s->nb_streams; i++) {
1333         st = s->streams[i];
1334
1335         if (st->parser) {
1336             av_parser_close(st->parser);
1337             st->parser = NULL;
1338             av_free_packet(&st->cur_pkt);
1339         }
1340         st->last_IP_pts = AV_NOPTS_VALUE;
1341         st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1342         st->reference_dts = AV_NOPTS_VALUE;
1343         /* fail safe */
1344         st->cur_ptr = NULL;
1345         st->cur_len = 0;
1346
1347         st->probe_packets = MAX_PROBE_PACKETS;
1348
1349         for(j=0; j<MAX_REORDER_DELAY+1; j++)
1350             st->pts_buffer[j]= AV_NOPTS_VALUE;
1351     }
1352 }
1353
1354 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1355     int i;
1356
1357     for(i = 0; i < s->nb_streams; i++) {
1358         AVStream *st = s->streams[i];
1359
1360         st->cur_dts = av_rescale(timestamp,
1361                                  st->time_base.den * (int64_t)ref_st->time_base.num,
1362                                  st->time_base.num * (int64_t)ref_st->time_base.den);
1363     }
1364 }
1365
1366 void ff_reduce_index(AVFormatContext *s, int stream_index)
1367 {
1368     AVStream *st= s->streams[stream_index];
1369     unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1370
1371     if((unsigned)st->nb_index_entries >= max_entries){
1372         int i;
1373         for(i=0; 2*i<st->nb_index_entries; i++)
1374             st->index_entries[i]= st->index_entries[2*i];
1375         st->nb_index_entries= i;
1376     }
1377 }
1378
1379 int av_add_index_entry(AVStream *st,
1380                             int64_t pos, int64_t timestamp, int size, int distance, int flags)
1381 {
1382     AVIndexEntry *entries, *ie;
1383     int index;
1384
1385     if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1386         return -1;
1387
1388     entries = av_fast_realloc(st->index_entries,
1389                               &st->index_entries_allocated_size,
1390                               (st->nb_index_entries + 1) *
1391                               sizeof(AVIndexEntry));
1392     if(!entries)
1393         return -1;
1394
1395     st->index_entries= entries;
1396
1397     index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1398
1399     if(index<0){
1400         index= st->nb_index_entries++;
1401         ie= &entries[index];
1402         assert(index==0 || ie[-1].timestamp < timestamp);
1403     }else{
1404         ie= &entries[index];
1405         if(ie->timestamp != timestamp){
1406             if(ie->timestamp <= timestamp)
1407                 return -1;
1408             memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1409             st->nb_index_entries++;
1410         }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1411             distance= ie->min_distance;
1412     }
1413
1414     ie->pos = pos;
1415     ie->timestamp = timestamp;
1416     ie->min_distance= distance;
1417     ie->size= size;
1418     ie->flags = flags;
1419
1420     return index;
1421 }
1422
1423 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1424                               int flags)
1425 {
1426     AVIndexEntry *entries= st->index_entries;
1427     int nb_entries= st->nb_index_entries;
1428     int a, b, m;
1429     int64_t timestamp;
1430
1431     a = - 1;
1432     b = nb_entries;
1433
1434     //optimize appending index entries at the end
1435     if(b && entries[b-1].timestamp < wanted_timestamp)
1436         a= b-1;
1437
1438     while (b - a > 1) {
1439         m = (a + b) >> 1;
1440         timestamp = entries[m].timestamp;
1441         if(timestamp >= wanted_timestamp)
1442             b = m;
1443         if(timestamp <= wanted_timestamp)
1444             a = m;
1445     }
1446     m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1447
1448     if(!(flags & AVSEEK_FLAG_ANY)){
1449         while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1450             m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1451         }
1452     }
1453
1454     if(m == nb_entries)
1455         return -1;
1456     return  m;
1457 }
1458
1459 #define DEBUG_SEEK
1460
1461 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1462     AVInputFormat *avif= s->iformat;
1463     int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1464     int64_t ts_min, ts_max, ts;
1465     int index;
1466     int64_t ret;
1467     AVStream *st;
1468
1469     if (stream_index < 0)
1470         return -1;
1471
1472 #ifdef DEBUG_SEEK
1473     av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1474 #endif
1475
1476     ts_max=
1477     ts_min= AV_NOPTS_VALUE;
1478     pos_limit= -1; //gcc falsely says it may be uninitialized
1479
1480     st= s->streams[stream_index];
1481     if(st->index_entries){
1482         AVIndexEntry *e;
1483
1484         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()
1485         index= FFMAX(index, 0);
1486         e= &st->index_entries[index];
1487
1488         if(e->timestamp <= target_ts || e->pos == e->min_distance){
1489             pos_min= e->pos;
1490             ts_min= e->timestamp;
1491 #ifdef DEBUG_SEEK
1492             av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1493                    pos_min,ts_min);
1494 #endif
1495         }else{
1496             assert(index==0);
1497         }
1498
1499         index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1500         assert(index < st->nb_index_entries);
1501         if(index >= 0){
1502             e= &st->index_entries[index];
1503             assert(e->timestamp >= target_ts);
1504             pos_max= e->pos;
1505             ts_max= e->timestamp;
1506             pos_limit= pos_max - e->min_distance;
1507 #ifdef DEBUG_SEEK
1508             av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1509                    pos_max,pos_limit, ts_max);
1510 #endif
1511         }
1512     }
1513
1514     pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1515     if(pos<0)
1516         return -1;
1517
1518     /* do the seek */
1519     if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1520         return ret;
1521
1522     av_update_cur_dts(s, st, ts);
1523
1524     return 0;
1525 }
1526
1527 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 )){
1528     int64_t pos, ts;
1529     int64_t start_pos, filesize;
1530     int no_change;
1531
1532 #ifdef DEBUG_SEEK
1533     av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1534 #endif
1535
1536     if(ts_min == AV_NOPTS_VALUE){
1537         pos_min = s->data_offset;
1538         ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1539         if (ts_min == AV_NOPTS_VALUE)
1540             return -1;
1541     }
1542
1543     if(ts_max == AV_NOPTS_VALUE){
1544         int step= 1024;
1545         filesize = url_fsize(s->pb);
1546         pos_max = filesize - 1;
1547         do{
1548             pos_max -= step;
1549             ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1550             step += step;
1551         }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1552         if (ts_max == AV_NOPTS_VALUE)
1553             return -1;
1554
1555         for(;;){
1556             int64_t tmp_pos= pos_max + 1;
1557             int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1558             if(tmp_ts == AV_NOPTS_VALUE)
1559                 break;
1560             ts_max= tmp_ts;
1561             pos_max= tmp_pos;
1562             if(tmp_pos >= filesize)
1563                 break;
1564         }
1565         pos_limit= pos_max;
1566     }
1567
1568     if(ts_min > ts_max){
1569         return -1;
1570     }else if(ts_min == ts_max){
1571         pos_limit= pos_min;
1572     }
1573
1574     no_change=0;
1575     while (pos_min < pos_limit) {
1576 #ifdef DEBUG_SEEK
1577         av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1578                pos_min, pos_max,
1579                ts_min, ts_max);
1580 #endif
1581         assert(pos_limit <= pos_max);
1582
1583         if(no_change==0){
1584             int64_t approximate_keyframe_distance= pos_max - pos_limit;
1585             // interpolate position (better than dichotomy)
1586             pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1587                 + pos_min - approximate_keyframe_distance;
1588         }else if(no_change==1){
1589             // bisection, if interpolation failed to change min or max pos last time
1590             pos = (pos_min + pos_limit)>>1;
1591         }else{
1592             /* linear search if bisection failed, can only happen if there
1593                are very few or no keyframes between min/max */
1594             pos=pos_min;
1595         }
1596         if(pos <= pos_min)
1597             pos= pos_min + 1;
1598         else if(pos > pos_limit)
1599             pos= pos_limit;
1600         start_pos= pos;
1601
1602         ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1603         if(pos == pos_max)
1604             no_change++;
1605         else
1606             no_change=0;
1607 #ifdef DEBUG_SEEK
1608         av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1609                pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1610                start_pos, no_change);
1611 #endif
1612         if(ts == AV_NOPTS_VALUE){
1613             av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1614             return -1;
1615         }
1616         assert(ts != AV_NOPTS_VALUE);
1617         if (target_ts <= ts) {
1618             pos_limit = start_pos - 1;
1619             pos_max = pos;
1620             ts_max = ts;
1621         }
1622         if (target_ts >= ts) {
1623             pos_min = pos;
1624             ts_min = ts;
1625         }
1626     }
1627
1628     pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1629     ts  = (flags & AVSEEK_FLAG_BACKWARD) ?  ts_min :  ts_max;
1630 #ifdef DEBUG_SEEK
1631     pos_min = pos;
1632     ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1633     pos_min++;
1634     ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1635     av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1636            pos, ts_min, target_ts, ts_max);
1637 #endif
1638     *ts_ret= ts;
1639     return pos;
1640 }
1641
1642 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1643     int64_t pos_min, pos_max;
1644 #if 0
1645     AVStream *st;
1646
1647     if (stream_index < 0)
1648         return -1;
1649
1650     st= s->streams[stream_index];
1651 #endif
1652
1653     pos_min = s->data_offset;
1654     pos_max = url_fsize(s->pb) - 1;
1655
1656     if     (pos < pos_min) pos= pos_min;
1657     else if(pos > pos_max) pos= pos_max;
1658
1659     url_fseek(s->pb, pos, SEEK_SET);
1660
1661 #if 0
1662     av_update_cur_dts(s, st, ts);
1663 #endif
1664     return 0;
1665 }
1666
1667 static int av_seek_frame_generic(AVFormatContext *s,
1668                                  int stream_index, int64_t timestamp, int flags)
1669 {
1670     int index;
1671     int64_t ret;
1672     AVStream *st;
1673     AVIndexEntry *ie;
1674
1675     st = s->streams[stream_index];
1676
1677     index = av_index_search_timestamp(st, timestamp, flags);
1678
1679     if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1680         return -1;
1681
1682     if(index < 0 || index==st->nb_index_entries-1){
1683         int i;
1684         AVPacket pkt;
1685
1686         if(st->nb_index_entries){
1687             assert(st->index_entries);
1688             ie= &st->index_entries[st->nb_index_entries-1];
1689             if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1690                 return ret;
1691             av_update_cur_dts(s, st, ie->timestamp);
1692         }else{
1693             if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1694                 return ret;
1695         }
1696         for(i=0;; i++) {
1697             int ret;
1698             do{
1699                 ret = av_read_frame(s, &pkt);
1700             }while(ret == AVERROR(EAGAIN));
1701             if(ret<0)
1702                 break;
1703             av_free_packet(&pkt);
1704             if(stream_index == pkt.stream_index){
1705                 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1706                     break;
1707             }
1708         }
1709         index = av_index_search_timestamp(st, timestamp, flags);
1710     }
1711     if (index < 0)
1712         return -1;
1713
1714     ff_read_frame_flush(s);
1715     if (s->iformat->read_seek){
1716         if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1717             return 0;
1718     }
1719     ie = &st->index_entries[index];
1720     if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1721         return ret;
1722     av_update_cur_dts(s, st, ie->timestamp);
1723
1724     return 0;
1725 }
1726
1727 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1728 {
1729     int ret;
1730     AVStream *st;
1731
1732     ff_read_frame_flush(s);
1733
1734     if(flags & AVSEEK_FLAG_BYTE)
1735         return av_seek_frame_byte(s, stream_index, timestamp, flags);
1736
1737     if(stream_index < 0){
1738         stream_index= av_find_default_stream_index(s);
1739         if(stream_index < 0)
1740             return -1;
1741
1742         st= s->streams[stream_index];
1743        /* timestamp for default must be expressed in AV_TIME_BASE units */
1744         timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1745     }
1746
1747     /* first, we try the format specific seek */
1748     if (s->iformat->read_seek)
1749         ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1750     else
1751         ret = -1;
1752     if (ret >= 0) {
1753         return 0;
1754     }
1755
1756     if(s->iformat->read_timestamp)
1757         return av_seek_frame_binary(s, stream_index, timestamp, flags);
1758     else
1759         return av_seek_frame_generic(s, stream_index, timestamp, flags);
1760 }
1761
1762 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1763 {
1764     if(min_ts > ts || max_ts < ts)
1765         return -1;
1766
1767     ff_read_frame_flush(s);
1768
1769     if (s->iformat->read_seek2)
1770         return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1771
1772     if(s->iformat->read_timestamp){
1773         //try to seek via read_timestamp()
1774     }
1775
1776     //Fallback to old API if new is not implemented but old is
1777     //Note the old has somewat different sematics
1778     if(s->iformat->read_seek || 1)
1779         return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1780
1781     // try some generic seek like av_seek_frame_generic() but with new ts semantics
1782 }
1783
1784 /*******************************************************/
1785
1786 /**
1787  * Return TRUE if the stream has accurate duration in any stream.
1788  *
1789  * @return TRUE if the stream has accurate duration for at least one component.
1790  */
1791 static int av_has_duration(AVFormatContext *ic)
1792 {
1793     int i;
1794     AVStream *st;
1795
1796     for(i = 0;i < ic->nb_streams; i++) {
1797         st = ic->streams[i];
1798         if (st->duration != AV_NOPTS_VALUE)
1799             return 1;
1800     }
1801     return 0;
1802 }
1803
1804 /**
1805  * Estimate the stream timings from the one of each components.
1806  *
1807  * Also computes the global bitrate if possible.
1808  */
1809 static void av_update_stream_timings(AVFormatContext *ic)
1810 {
1811     int64_t start_time, start_time1, end_time, end_time1;
1812     int64_t duration, duration1;
1813     int i;
1814     AVStream *st;
1815
1816     start_time = INT64_MAX;
1817     end_time = INT64_MIN;
1818     duration = INT64_MIN;
1819     for(i = 0;i < ic->nb_streams; i++) {
1820         st = ic->streams[i];
1821         if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1822             start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1823             if (start_time1 < start_time)
1824                 start_time = start_time1;
1825             if (st->duration != AV_NOPTS_VALUE) {
1826                 end_time1 = start_time1
1827                           + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1828                 if (end_time1 > end_time)
1829                     end_time = end_time1;
1830             }
1831         }
1832         if (st->duration != AV_NOPTS_VALUE) {
1833             duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1834             if (duration1 > duration)
1835                 duration = duration1;
1836         }
1837     }
1838     if (start_time != INT64_MAX) {
1839         ic->start_time = start_time;
1840         if (end_time != INT64_MIN) {
1841             if (end_time - start_time > duration)
1842                 duration = end_time - start_time;
1843         }
1844     }
1845     if (duration != INT64_MIN) {
1846         ic->duration = duration;
1847         if (ic->file_size > 0) {
1848             /* compute the bitrate */
1849             ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1850                 (double)ic->duration;
1851         }
1852     }
1853 }
1854
1855 static void fill_all_stream_timings(AVFormatContext *ic)
1856 {
1857     int i;
1858     AVStream *st;
1859
1860     av_update_stream_timings(ic);
1861     for(i = 0;i < ic->nb_streams; i++) {
1862         st = ic->streams[i];
1863         if (st->start_time == AV_NOPTS_VALUE) {
1864             if(ic->start_time != AV_NOPTS_VALUE)
1865                 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1866             if(ic->duration != AV_NOPTS_VALUE)
1867                 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1868         }
1869     }
1870 }
1871
1872 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1873 {
1874     int64_t filesize, duration;
1875     int bit_rate, i;
1876     AVStream *st;
1877
1878     /* if bit_rate is already set, we believe it */
1879     if (ic->bit_rate <= 0) {
1880         bit_rate = 0;
1881         for(i=0;i<ic->nb_streams;i++) {
1882             st = ic->streams[i];
1883             if (st->codec->bit_rate > 0)
1884             bit_rate += st->codec->bit_rate;
1885         }
1886         ic->bit_rate = bit_rate;
1887     }
1888
1889     /* if duration is already set, we believe it */
1890     if (ic->duration == AV_NOPTS_VALUE &&
1891         ic->bit_rate != 0 &&
1892         ic->file_size != 0)  {
1893         filesize = ic->file_size;
1894         if (filesize > 0) {
1895             for(i = 0; i < ic->nb_streams; i++) {
1896                 st = ic->streams[i];
1897                 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1898                 if (st->duration == AV_NOPTS_VALUE)
1899                     st->duration = duration;
1900             }
1901         }
1902     }
1903 }
1904
1905 #define DURATION_MAX_READ_SIZE 250000
1906 #define DURATION_MAX_RETRY 3
1907
1908 /* only usable for MPEG-PS streams */
1909 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1910 {
1911     AVPacket pkt1, *pkt = &pkt1;
1912     AVStream *st;
1913     int read_size, i, ret;
1914     int64_t end_time;
1915     int64_t filesize, offset, duration;
1916     int retry=0;
1917
1918     ic->cur_st = NULL;
1919
1920     /* flush packet queue */
1921     flush_packet_queue(ic);
1922
1923     for (i=0; i<ic->nb_streams; i++) {
1924         st = ic->streams[i];
1925         if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1926             av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1927
1928         if (st->parser) {
1929             av_parser_close(st->parser);
1930             st->parser= NULL;
1931             av_free_packet(&st->cur_pkt);
1932         }
1933     }
1934
1935     /* estimate the end time (duration) */
1936     /* XXX: may need to support wrapping */
1937     filesize = ic->file_size;
1938     end_time = AV_NOPTS_VALUE;
1939     do{
1940     offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1941     if (offset < 0)
1942         offset = 0;
1943
1944     url_fseek(ic->pb, offset, SEEK_SET);
1945     read_size = 0;
1946     for(;;) {
1947         if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1948             break;
1949
1950         do{
1951             ret = av_read_packet(ic, pkt);
1952         }while(ret == AVERROR(EAGAIN));
1953         if (ret != 0)
1954             break;
1955         read_size += pkt->size;
1956         st = ic->streams[pkt->stream_index];
1957         if (pkt->pts != AV_NOPTS_VALUE &&
1958             (st->start_time != AV_NOPTS_VALUE ||
1959              st->first_dts  != AV_NOPTS_VALUE)) {
1960             duration = end_time = pkt->pts;
1961             if (st->start_time != AV_NOPTS_VALUE)  duration -= st->start_time;
1962             else                                   duration -= st->first_dts;
1963             if (duration < 0)
1964                 duration += 1LL<<st->pts_wrap_bits;
1965             if (duration > 0) {
1966                 if (st->duration == AV_NOPTS_VALUE ||
1967                     st->duration < duration)
1968                     st->duration = duration;
1969             }
1970         }
1971         av_free_packet(pkt);
1972     }
1973     }while(   end_time==AV_NOPTS_VALUE
1974            && filesize > (DURATION_MAX_READ_SIZE<<retry)
1975            && ++retry <= DURATION_MAX_RETRY);
1976
1977     fill_all_stream_timings(ic);
1978
1979     url_fseek(ic->pb, old_offset, SEEK_SET);
1980     for (i=0; i<ic->nb_streams; i++) {
1981         st= ic->streams[i];
1982         st->cur_dts= st->first_dts;
1983         st->last_IP_pts = AV_NOPTS_VALUE;
1984     }
1985 }
1986
1987 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1988 {
1989     int64_t file_size;
1990
1991     /* get the file size, if possible */
1992     if (ic->iformat->flags & AVFMT_NOFILE) {
1993         file_size = 0;
1994     } else {
1995         file_size = url_fsize(ic->pb);
1996         if (file_size < 0)
1997             file_size = 0;
1998     }
1999     ic->file_size = file_size;
2000
2001     if ((!strcmp(ic->iformat->name, "mpeg") ||
2002          !strcmp(ic->iformat->name, "mpegts")) &&
2003         file_size && !url_is_streamed(ic->pb)) {
2004         /* get accurate estimate from the PTSes */
2005         av_estimate_timings_from_pts(ic, old_offset);
2006     } else if (av_has_duration(ic)) {
2007         /* at least one component has timings - we use them for all
2008            the components */
2009         fill_all_stream_timings(ic);
2010     } else {
2011         av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2012         /* less precise: use bitrate info */
2013         av_estimate_timings_from_bit_rate(ic);
2014     }
2015     av_update_stream_timings(ic);
2016
2017 #if 0
2018     {
2019         int i;
2020         AVStream *st;
2021         for(i = 0;i < ic->nb_streams; i++) {
2022             st = ic->streams[i];
2023         printf("%d: start_time: %0.3f duration: %0.3f\n",
2024                i, (double)st->start_time / AV_TIME_BASE,
2025                (double)st->duration / AV_TIME_BASE);
2026         }
2027         printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2028                (double)ic->start_time / AV_TIME_BASE,
2029                (double)ic->duration / AV_TIME_BASE,
2030                ic->bit_rate / 1000);
2031     }
2032 #endif
2033 }
2034
2035 static int has_codec_parameters(AVCodecContext *enc)
2036 {
2037     int val;
2038     switch(enc->codec_type) {
2039     case AVMEDIA_TYPE_AUDIO:
2040         val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2041         if(!enc->frame_size &&
2042            (enc->codec_id == CODEC_ID_VORBIS ||
2043             enc->codec_id == CODEC_ID_AAC ||
2044             enc->codec_id == CODEC_ID_MP1 ||
2045             enc->codec_id == CODEC_ID_MP2 ||
2046             enc->codec_id == CODEC_ID_MP3 ||
2047             enc->codec_id == CODEC_ID_SPEEX))
2048             return 0;
2049         break;
2050     case AVMEDIA_TYPE_VIDEO:
2051         val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2052         break;
2053     default:
2054         val = 1;
2055         break;
2056     }
2057     return enc->codec_id != CODEC_ID_NONE && val != 0;
2058 }
2059
2060 static int has_decode_delay_been_guessed(AVStream *st)
2061 {
2062     return st->codec->codec_id != CODEC_ID_H264 ||
2063         st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2064 }
2065
2066 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2067 {
2068     int16_t *samples;
2069     AVCodec *codec;
2070     int got_picture, data_size, ret=0;
2071     AVFrame picture;
2072
2073     if(!st->codec->codec){
2074         codec = avcodec_find_decoder(st->codec->codec_id);
2075         if (!codec)
2076             return -1;
2077         ret = avcodec_open(st->codec, codec);
2078         if (ret < 0)
2079             return ret;
2080     }
2081
2082     if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2083         switch(st->codec->codec_type) {
2084         case AVMEDIA_TYPE_VIDEO:
2085             avcodec_get_frame_defaults(&picture);
2086             ret = avcodec_decode_video2(st->codec, &picture,
2087                                         &got_picture, avpkt);
2088             break;
2089         case AVMEDIA_TYPE_AUDIO:
2090             data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2091             samples = av_malloc(data_size);
2092             if (!samples)
2093                 goto fail;
2094             ret = avcodec_decode_audio3(st->codec, samples,
2095                                         &data_size, avpkt);
2096             av_free(samples);
2097             break;
2098         default:
2099             break;
2100         }
2101     }
2102  fail:
2103     return ret;
2104 }
2105
2106 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2107 {
2108     while (tags->id != CODEC_ID_NONE) {
2109         if (tags->id == id)
2110             return tags->tag;
2111         tags++;
2112     }
2113     return 0;
2114 }
2115
2116 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2117 {
2118     int i;
2119     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2120         if(tag == tags[i].tag)
2121             return tags[i].id;
2122     }
2123     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2124         if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2125             return tags[i].id;
2126     }
2127     return CODEC_ID_NONE;
2128 }
2129
2130 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2131 {
2132     int i;
2133     for(i=0; tags && tags[i]; i++){
2134         int tag= ff_codec_get_tag(tags[i], id);
2135         if(tag) return tag;
2136     }
2137     return 0;
2138 }
2139
2140 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2141 {
2142     int i;
2143     for(i=0; tags && tags[i]; i++){
2144         enum CodecID id= ff_codec_get_id(tags[i], tag);
2145         if(id!=CODEC_ID_NONE) return id;
2146     }
2147     return CODEC_ID_NONE;
2148 }
2149
2150 static void compute_chapters_end(AVFormatContext *s)
2151 {
2152     unsigned int i;
2153
2154     for (i=0; i+1<s->nb_chapters; i++)
2155         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2156             assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2157             assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2158             s->chapters[i]->end = s->chapters[i+1]->start;
2159         }
2160
2161     if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2162         assert(s->start_time != AV_NOPTS_VALUE);
2163         assert(s->duration > 0);
2164         s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2165                                            AV_TIME_BASE_Q,
2166                                            s->chapters[i]->time_base);
2167     }
2168 }
2169
2170 static int get_std_framerate(int i){
2171     if(i<60*12) return i*1001;
2172     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2173 }
2174
2175 /*
2176  * Is the time base unreliable.
2177  * This is a heuristic to balance between quick acceptance of the values in
2178  * the headers vs. some extra checks.
2179  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2180  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2181  * And there are "variable" fps files this needs to detect as well.
2182  */
2183 static int tb_unreliable(AVCodecContext *c){
2184     if(   c->time_base.den >= 101L*c->time_base.num
2185        || c->time_base.den <    5L*c->time_base.num
2186 /*       || c->codec_tag == AV_RL32("DIVX")
2187        || c->codec_tag == AV_RL32("XVID")*/
2188        || c->codec_id == CODEC_ID_MPEG2VIDEO
2189        || c->codec_id == CODEC_ID_H264
2190        )
2191         return 1;
2192     return 0;
2193 }
2194
2195 int av_find_stream_info(AVFormatContext *ic)
2196 {
2197     int i, count, ret, read_size, j;
2198     AVStream *st;
2199     AVPacket pkt1, *pkt;
2200     int64_t old_offset = url_ftell(ic->pb);
2201
2202     for(i=0;i<ic->nb_streams;i++) {
2203         AVCodec *codec;
2204         st = ic->streams[i];
2205         if (st->codec->codec_id == CODEC_ID_AAC) {
2206             st->codec->sample_rate = 0;
2207             st->codec->frame_size = 0;
2208             st->codec->channels = 0;
2209         }
2210         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2211             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2212 /*            if(!st->time_base.num)
2213                 st->time_base= */
2214             if(!st->codec->time_base.num)
2215                 st->codec->time_base= st->time_base;
2216         }
2217         //only for the split stuff
2218         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2219             st->parser = av_parser_init(st->codec->codec_id);
2220             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2221                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2222             }
2223         }
2224         assert(!st->codec->codec);
2225         codec = avcodec_find_decoder(st->codec->codec_id);
2226
2227         /* Force decoding of at least one frame of codec data
2228          * this makes sure the codec initializes the channel configuration
2229          * and does not trust the values from the container.
2230          */
2231         if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2232             st->codec->channels = 0;
2233
2234         /* Ensure that subtitle_header is properly set. */
2235         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2236             && codec && !st->codec->codec)
2237             avcodec_open(st->codec, codec);
2238
2239         //try to just open decoders, in case this is enough to get parameters
2240         if(!has_codec_parameters(st->codec)){
2241             if (codec && !st->codec->codec)
2242                 avcodec_open(st->codec, codec);
2243         }
2244     }
2245
2246     for (i=0; i<ic->nb_streams; i++) {
2247         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2248     }
2249
2250     count = 0;
2251     read_size = 0;
2252     for(;;) {
2253         if(url_interrupt_cb()){
2254             ret= AVERROR(EINTR);
2255             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2256             break;
2257         }
2258
2259         /* check if one codec still needs to be handled */
2260         for(i=0;i<ic->nb_streams;i++) {
2261             st = ic->streams[i];
2262             if (!has_codec_parameters(st->codec))
2263                 break;
2264             /* variable fps and no guess at the real fps */
2265             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2266                && st->info->duration_count<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2267                 break;
2268             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2269                 break;
2270             if(st->first_dts == AV_NOPTS_VALUE)
2271                 break;
2272         }
2273         if (i == ic->nb_streams) {
2274             /* NOTE: if the format has no header, then we need to read
2275                some packets to get most of the streams, so we cannot
2276                stop here */
2277             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2278                 /* if we found the info for all the codecs, we can stop */
2279                 ret = count;
2280                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2281                 break;
2282             }
2283         }
2284         /* we did not get all the codec info, but we read too much data */
2285         if (read_size >= ic->probesize) {
2286             ret = count;
2287             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2288             break;
2289         }
2290
2291         /* NOTE: a new stream can be added there if no header in file
2292            (AVFMTCTX_NOHEADER) */
2293         ret = av_read_frame_internal(ic, &pkt1);
2294         if (ret < 0 && ret != AVERROR(EAGAIN)) {
2295             /* EOF or error */
2296             ret = -1; /* we could not have all the codec parameters before EOF */
2297             for(i=0;i<ic->nb_streams;i++) {
2298                 st = ic->streams[i];
2299                 if (!has_codec_parameters(st->codec)){
2300                     char buf[256];
2301                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2302                     av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2303                 } else {
2304                     ret = 0;
2305                 }
2306             }
2307             break;
2308         }
2309
2310         if (ret == AVERROR(EAGAIN))
2311             continue;
2312
2313         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2314         if ((ret = av_dup_packet(pkt)) < 0)
2315             goto find_stream_info_err;
2316
2317         read_size += pkt->size;
2318
2319         st = ic->streams[pkt->stream_index];
2320         if (st->codec_info_nb_frames>1) {
2321             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) {
2322                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2323                 break;
2324             }
2325             st->info->codec_info_duration += pkt->duration;
2326         }
2327         {
2328             int64_t last = st->info->last_dts;
2329             int64_t duration= pkt->dts - last;
2330
2331             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2332                 double dur= duration * av_q2d(st->time_base);
2333
2334 //                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2335 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2336                 if (st->info->duration_count < 2)
2337                     memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2338                 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2339                     int framerate= get_std_framerate(i);
2340                     int ticks= lrintf(dur*framerate/(1001*12));
2341                     double error= dur - ticks*1001*12/(double)framerate;
2342                     st->info->duration_error[i] += error*error;
2343                 }
2344                 st->info->duration_count++;
2345                 // ignore the first 4 values, they might have some random jitter
2346                 if (st->info->duration_count > 3)
2347                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2348             }
2349             if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2350                 st->info->last_dts = pkt->dts;
2351         }
2352         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2353             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2354             if(i){
2355                 st->codec->extradata_size= i;
2356                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2357                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2358                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2359             }
2360         }
2361
2362         /* if still no information, we try to open the codec and to
2363            decompress the frame. We try to avoid that in most cases as
2364            it takes longer and uses more memory. For MPEG-4, we need to
2365            decompress for QuickTime. */
2366         if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2367             try_decode_frame(st, pkt);
2368
2369         st->codec_info_nb_frames++;
2370         count++;
2371     }
2372
2373     // close codecs which were opened in try_decode_frame()
2374     for(i=0;i<ic->nb_streams;i++) {
2375         st = ic->streams[i];
2376         if(st->codec->codec)
2377             avcodec_close(st->codec);
2378     }
2379     for(i=0;i<ic->nb_streams;i++) {
2380         st = ic->streams[i];
2381         if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2382             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2383                      (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2384                       st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2385         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2386             if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2387                 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2388
2389             // the check for tb_unreliable() is not completely correct, since this is not about handling
2390             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2391             // ipmovie.c produces.
2392             if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2393                 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);
2394             if (st->info->duration_count && !st->r_frame_rate.num
2395                && tb_unreliable(st->codec) /*&&
2396                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2397                st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2398                 int num = 0;
2399                 double best_error= 2*av_q2d(st->time_base);
2400                 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2401
2402                 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2403                     double error = st->info->duration_error[j] * get_std_framerate(j);
2404 //                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2405 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2406                     if(error < best_error){
2407                         best_error= error;
2408                         num = get_std_framerate(j);
2409                     }
2410                 }
2411                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2412                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2413                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2414             }
2415
2416             if (!st->r_frame_rate.num){
2417                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2418                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2419                     st->r_frame_rate.num = st->codec->time_base.den;
2420                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2421                 }else{
2422                     st->r_frame_rate.num = st->time_base.den;
2423                     st->r_frame_rate.den = st->time_base.num;
2424                 }
2425             }
2426         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2427             if(!st->codec->bits_per_coded_sample)
2428                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2429         }
2430     }
2431
2432     av_estimate_timings(ic, old_offset);
2433
2434     compute_chapters_end(ic);
2435
2436 #if 0
2437     /* correct DTS for B-frame streams with no timestamps */
2438     for(i=0;i<ic->nb_streams;i++) {
2439         st = ic->streams[i];
2440         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2441             if(b-frames){
2442                 ppktl = &ic->packet_buffer;
2443                 while(ppkt1){
2444                     if(ppkt1->stream_index != i)
2445                         continue;
2446                     if(ppkt1->pkt->dts < 0)
2447                         break;
2448                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2449                         break;
2450                     ppkt1->pkt->dts -= delta;
2451                     ppkt1= ppkt1->next;
2452                 }
2453                 if(ppkt1)
2454                     continue;
2455                 st->cur_dts -= delta;
2456             }
2457         }
2458     }
2459 #endif
2460
2461  find_stream_info_err:
2462     for (i=0; i < ic->nb_streams; i++)
2463         av_freep(&ic->streams[i]->info);
2464     return ret;
2465 }
2466
2467 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2468 {
2469     int i, j;
2470
2471     for (i = 0; i < ic->nb_programs; i++)
2472         for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2473             if (ic->programs[i]->stream_index[j] == s)
2474                 return ic->programs[i];
2475     return NULL;
2476 }
2477
2478 int av_find_best_stream(AVFormatContext *ic,
2479                         enum AVMediaType type,
2480                         int wanted_stream_nb,
2481                         int related_stream,
2482                         AVCodec **decoder_ret,
2483                         int flags)
2484 {
2485     int i, nb_streams = ic->nb_streams, stream_number = 0;
2486     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2487     unsigned *program = NULL;
2488     AVCodec *decoder = NULL, *best_decoder = NULL;
2489
2490     if (related_stream >= 0 && wanted_stream_nb < 0) {
2491         AVProgram *p = find_program_from_stream(ic, related_stream);
2492         if (p) {
2493             program = p->stream_index;
2494             nb_streams = p->nb_stream_indexes;
2495         }
2496     }
2497     for (i = 0; i < nb_streams; i++) {
2498         AVStream *st = ic->streams[program ? program[i] : i];
2499         AVCodecContext *avctx = st->codec;
2500         if (avctx->codec_type != type)
2501             continue;
2502         if (wanted_stream_nb >= 0 && stream_number++ != wanted_stream_nb)
2503             continue;
2504         if (decoder_ret) {
2505             decoder = avcodec_find_decoder(ic->streams[i]->codec->codec_id);
2506             if (!decoder) {
2507                 if (ret < 0)
2508                     ret = AVERROR_DECODER_NOT_FOUND;
2509                 continue;
2510             }
2511         }
2512         if (best_count >= st->codec_info_nb_frames)
2513             continue;
2514         best_count = st->codec_info_nb_frames;
2515         ret = i;
2516         best_decoder = decoder;
2517         if (program && i == nb_streams - 1 && ret < 0) {
2518             program = NULL;
2519             nb_streams = ic->nb_streams;
2520             i = 0; /* no related stream found, try again with everything */
2521         }
2522     }
2523     if (decoder_ret)
2524         *decoder_ret = best_decoder;
2525     return ret;
2526 }
2527
2528 /*******************************************************/
2529
2530 int av_read_play(AVFormatContext *s)
2531 {
2532     if (s->iformat->read_play)
2533         return s->iformat->read_play(s);
2534     if (s->pb)
2535         return av_url_read_fpause(s->pb, 0);
2536     return AVERROR(ENOSYS);
2537 }
2538
2539 int av_read_pause(AVFormatContext *s)
2540 {
2541     if (s->iformat->read_pause)
2542         return s->iformat->read_pause(s);
2543     if (s->pb)
2544         return av_url_read_fpause(s->pb, 1);
2545     return AVERROR(ENOSYS);
2546 }
2547
2548 void av_close_input_stream(AVFormatContext *s)
2549 {
2550     int i;
2551     AVStream *st;
2552
2553     flush_packet_queue(s);
2554     if (s->iformat->read_close)
2555         s->iformat->read_close(s);
2556     for(i=0;i<s->nb_streams;i++) {
2557         /* free all data in a stream component */
2558         st = s->streams[i];
2559         if (st->parser) {
2560             av_parser_close(st->parser);
2561             av_free_packet(&st->cur_pkt);
2562         }
2563         av_metadata_free(&st->metadata);
2564         av_free(st->index_entries);
2565         av_free(st->codec->extradata);
2566         av_free(st->codec->subtitle_header);
2567         av_free(st->codec);
2568 #if FF_API_OLD_METADATA
2569         av_free(st->filename);
2570 #endif
2571         av_free(st->priv_data);
2572         av_free(st->info);
2573         av_free(st);
2574     }
2575     for(i=s->nb_programs-1; i>=0; i--) {
2576 #if FF_API_OLD_METADATA
2577         av_freep(&s->programs[i]->provider_name);
2578         av_freep(&s->programs[i]->name);
2579 #endif
2580         av_metadata_free(&s->programs[i]->metadata);
2581         av_freep(&s->programs[i]->stream_index);
2582         av_freep(&s->programs[i]);
2583     }
2584     av_freep(&s->programs);
2585     av_freep(&s->priv_data);
2586     while(s->nb_chapters--) {
2587 #if FF_API_OLD_METADATA
2588         av_free(s->chapters[s->nb_chapters]->title);
2589 #endif
2590         av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2591         av_free(s->chapters[s->nb_chapters]);
2592     }
2593     av_freep(&s->chapters);
2594     av_metadata_free(&s->metadata);
2595     av_freep(&s->key);
2596     av_free(s);
2597 }
2598
2599 void av_close_input_file(AVFormatContext *s)
2600 {
2601     ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2602     av_close_input_stream(s);
2603     if (pb)
2604         url_fclose(pb);
2605 }
2606
2607 AVStream *av_new_stream(AVFormatContext *s, int id)
2608 {
2609     AVStream *st;
2610     int i;
2611
2612 #if FF_API_MAX_STREAMS
2613     if (s->nb_streams >= MAX_STREAMS){
2614         av_log(s, AV_LOG_ERROR, "Too many streams\n");
2615         return NULL;
2616     }
2617 #else
2618     AVStream **streams;
2619
2620     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2621         return NULL;
2622     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2623     if (!streams)
2624         return NULL;
2625     s->streams = streams;
2626 #endif
2627
2628     st = av_mallocz(sizeof(AVStream));
2629     if (!st)
2630         return NULL;
2631     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2632         av_free(st);
2633         return NULL;
2634     }
2635
2636     st->codec= avcodec_alloc_context();
2637     if (s->iformat) {
2638         /* no default bitrate if decoding */
2639         st->codec->bit_rate = 0;
2640     }
2641     st->index = s->nb_streams;
2642     st->id = id;
2643     st->start_time = AV_NOPTS_VALUE;
2644     st->duration = AV_NOPTS_VALUE;
2645         /* we set the current DTS to 0 so that formats without any timestamps
2646            but durations get some timestamps, formats with some unknown
2647            timestamps have their first few packets buffered and the
2648            timestamps corrected before they are returned to the user */
2649     st->cur_dts = 0;
2650     st->first_dts = AV_NOPTS_VALUE;
2651     st->probe_packets = MAX_PROBE_PACKETS;
2652
2653     /* default pts setting is MPEG-like */
2654     av_set_pts_info(st, 33, 1, 90000);
2655     st->last_IP_pts = AV_NOPTS_VALUE;
2656     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2657         st->pts_buffer[i]= AV_NOPTS_VALUE;
2658     st->reference_dts = AV_NOPTS_VALUE;
2659
2660     st->sample_aspect_ratio = (AVRational){0,1};
2661
2662     s->streams[s->nb_streams++] = st;
2663     return st;
2664 }
2665
2666 AVProgram *av_new_program(AVFormatContext *ac, int id)
2667 {
2668     AVProgram *program=NULL;
2669     int i;
2670
2671 #ifdef DEBUG_SI
2672     av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2673 #endif
2674
2675     for(i=0; i<ac->nb_programs; i++)
2676         if(ac->programs[i]->id == id)
2677             program = ac->programs[i];
2678
2679     if(!program){
2680         program = av_mallocz(sizeof(AVProgram));
2681         if (!program)
2682             return NULL;
2683         dynarray_add(&ac->programs, &ac->nb_programs, program);
2684         program->discard = AVDISCARD_NONE;
2685     }
2686     program->id = id;
2687
2688     return program;
2689 }
2690
2691 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2692 {
2693     AVChapter *chapter = NULL;
2694     int i;
2695
2696     for(i=0; i<s->nb_chapters; i++)
2697         if(s->chapters[i]->id == id)
2698             chapter = s->chapters[i];
2699
2700     if(!chapter){
2701         chapter= av_mallocz(sizeof(AVChapter));
2702         if(!chapter)
2703             return NULL;
2704         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2705     }
2706 #if FF_API_OLD_METADATA
2707     av_free(chapter->title);
2708 #endif
2709     av_metadata_set2(&chapter->metadata, "title", title, 0);
2710     chapter->id    = id;
2711     chapter->time_base= time_base;
2712     chapter->start = start;
2713     chapter->end   = end;
2714
2715     return chapter;
2716 }
2717
2718 /************************************************************/
2719 /* output media file */
2720
2721 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2722 {
2723     int ret;
2724
2725     if (s->oformat->priv_data_size > 0) {
2726         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2727         if (!s->priv_data)
2728             return AVERROR(ENOMEM);
2729         if (s->oformat->priv_class) {
2730             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2731             av_opt_set_defaults(s->priv_data);
2732         }
2733     } else
2734         s->priv_data = NULL;
2735
2736     if (s->oformat->set_parameters) {
2737         ret = s->oformat->set_param