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