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