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