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