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