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