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