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