lavf: force single-threaded decoding 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 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2134 {
2135     AVCodec *codec;
2136     int got_picture = 1, ret = 0;
2137     AVFrame picture;
2138     AVPacket pkt = *avpkt;
2139
2140     if(!st->codec->codec){
2141         AVDictionary *thread_opt = NULL;
2142
2143         codec = avcodec_find_decoder(st->codec->codec_id);
2144         if (!codec)
2145             return -1;
2146
2147         /* force thread count to 1 since the h264 decoder will not extract SPS
2148          *  and PPS to extradata during multi-threaded decoding */
2149         av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2150         ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2151         if (!options)
2152             av_dict_free(&thread_opt);
2153         if (ret < 0)
2154             return ret;
2155     }
2156
2157     while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2158            ret >= 0 &&
2159            (!has_codec_parameters(st->codec)  ||
2160            !has_decode_delay_been_guessed(st) ||
2161            (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2162         got_picture = 0;
2163         avcodec_get_frame_defaults(&picture);
2164         switch(st->codec->codec_type) {
2165         case AVMEDIA_TYPE_VIDEO:
2166             ret = avcodec_decode_video2(st->codec, &picture,
2167                                         &got_picture, &pkt);
2168             break;
2169         case AVMEDIA_TYPE_AUDIO:
2170             ret = avcodec_decode_audio4(st->codec, &picture, &got_picture, &pkt);
2171             break;
2172         default:
2173             break;
2174         }
2175         if (ret >= 0) {
2176             if (got_picture)
2177                 st->info->nb_decoded_frames++;
2178             pkt.data += ret;
2179             pkt.size -= ret;
2180         }
2181     }
2182     return ret;
2183 }
2184
2185 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2186 {
2187     while (tags->id != CODEC_ID_NONE) {
2188         if (tags->id == id)
2189             return tags->tag;
2190         tags++;
2191     }
2192     return 0;
2193 }
2194
2195 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2196 {
2197     int i;
2198     for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2199         if(tag == tags[i].tag)
2200             return tags[i].id;
2201     }
2202     for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2203         if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2204             return tags[i].id;
2205     }
2206     return CODEC_ID_NONE;
2207 }
2208
2209 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2210 {
2211     int i;
2212     for(i=0; tags && tags[i]; i++){
2213         int tag= ff_codec_get_tag(tags[i], id);
2214         if(tag) return tag;
2215     }
2216     return 0;
2217 }
2218
2219 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2220 {
2221     int i;
2222     for(i=0; tags && tags[i]; i++){
2223         enum CodecID id= ff_codec_get_id(tags[i], tag);
2224         if(id!=CODEC_ID_NONE) return id;
2225     }
2226     return CODEC_ID_NONE;
2227 }
2228
2229 static void compute_chapters_end(AVFormatContext *s)
2230 {
2231     unsigned int i, j;
2232     int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2233
2234     for (i = 0; i < s->nb_chapters; i++)
2235         if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2236             AVChapter *ch = s->chapters[i];
2237             int64_t   end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2238                                      : INT64_MAX;
2239
2240             for (j = 0; j < s->nb_chapters; j++) {
2241                 AVChapter *ch1 = s->chapters[j];
2242                 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2243                 if (j != i && next_start > ch->start && next_start < end)
2244                     end = next_start;
2245             }
2246             ch->end = (end == INT64_MAX) ? ch->start : end;
2247         }
2248 }
2249
2250 static int get_std_framerate(int i){
2251     if(i<60*12) return i*1001;
2252     else        return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2253 }
2254
2255 /*
2256  * Is the time base unreliable.
2257  * This is a heuristic to balance between quick acceptance of the values in
2258  * the headers vs. some extra checks.
2259  * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2260  * MPEG-2 commonly misuses field repeat flags to store different framerates.
2261  * And there are "variable" fps files this needs to detect as well.
2262  */
2263 static int tb_unreliable(AVCodecContext *c){
2264     if(   c->time_base.den >= 101L*c->time_base.num
2265        || c->time_base.den <    5L*c->time_base.num
2266 /*       || c->codec_tag == AV_RL32("DIVX")
2267        || c->codec_tag == AV_RL32("XVID")*/
2268        || c->codec_id == CODEC_ID_MPEG2VIDEO
2269        || c->codec_id == CODEC_ID_H264
2270        )
2271         return 1;
2272     return 0;
2273 }
2274
2275 #if FF_API_FORMAT_PARAMETERS
2276 int av_find_stream_info(AVFormatContext *ic)
2277 {
2278     return avformat_find_stream_info(ic, NULL);
2279 }
2280 #endif
2281
2282 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2283 {
2284     int i, count, ret, read_size, j;
2285     AVStream *st;
2286     AVPacket pkt1, *pkt;
2287     int64_t old_offset = avio_tell(ic->pb);
2288     int orig_nb_streams = ic->nb_streams;        // new streams might appear, no options for those
2289
2290     for(i=0;i<ic->nb_streams;i++) {
2291         AVCodec *codec;
2292         AVDictionary *thread_opt = NULL;
2293         st = ic->streams[i];
2294
2295         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2296             st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2297 /*            if(!st->time_base.num)
2298                 st->time_base= */
2299             if(!st->codec->time_base.num)
2300                 st->codec->time_base= st->time_base;
2301         }
2302         //only for the split stuff
2303         if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2304             st->parser = av_parser_init(st->codec->codec_id);
2305             if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2306                 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2307             }
2308         }
2309         assert(!st->codec->codec);
2310         codec = avcodec_find_decoder(st->codec->codec_id);
2311
2312         /* force thread count to 1 since the h264 decoder will not extract SPS
2313          *  and PPS to extradata during multi-threaded decoding */
2314         av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2315
2316         /* Ensure that subtitle_header is properly set. */
2317         if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2318             && codec && !st->codec->codec)
2319             avcodec_open2(st->codec, codec, options ? &options[i]
2320                               : &thread_opt);
2321
2322         //try to just open decoders, in case this is enough to get parameters
2323         if(!has_codec_parameters(st->codec)){
2324             if (codec && !st->codec->codec)
2325                 avcodec_open2(st->codec, codec, options ? &options[i]
2326                               : &thread_opt);
2327         }
2328         if (!options)
2329             av_dict_free(&thread_opt);
2330     }
2331
2332     for (i=0; i<ic->nb_streams; i++) {
2333         ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2334     }
2335
2336     count = 0;
2337     read_size = 0;
2338     for(;;) {
2339         if (ff_check_interrupt(&ic->interrupt_callback)){
2340             ret= AVERROR_EXIT;
2341             av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2342             break;
2343         }
2344
2345         /* check if one codec still needs to be handled */
2346         for(i=0;i<ic->nb_streams;i++) {
2347             int fps_analyze_framecount = 20;
2348
2349             st = ic->streams[i];
2350             if (!has_codec_parameters(st->codec))
2351                 break;
2352             /* if the timebase is coarse (like the usual millisecond precision
2353                of mkv), we need to analyze more frames to reliably arrive at
2354                the correct fps */
2355             if (av_q2d(st->time_base) > 0.0005)
2356                 fps_analyze_framecount *= 2;
2357             if (ic->fps_probe_size >= 0)
2358                 fps_analyze_framecount = ic->fps_probe_size;
2359             /* variable fps and no guess at the real fps */
2360             if(   tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2361                && st->info->duration_count < fps_analyze_framecount
2362                && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2363                 break;
2364             if(st->parser && st->parser->parser->split && !st->codec->extradata)
2365                 break;
2366             if(st->first_dts == AV_NOPTS_VALUE)
2367                 break;
2368         }
2369         if (i == ic->nb_streams) {
2370             /* NOTE: if the format has no header, then we need to read
2371                some packets to get most of the streams, so we cannot
2372                stop here */
2373             if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2374                 /* if we found the info for all the codecs, we can stop */
2375                 ret = count;
2376                 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2377                 break;
2378             }
2379         }
2380         /* we did not get all the codec info, but we read too much data */
2381         if (read_size >= ic->probesize) {
2382             ret = count;
2383             av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2384             break;
2385         }
2386
2387         /* NOTE: a new stream can be added there if no header in file
2388            (AVFMTCTX_NOHEADER) */
2389         ret = read_frame_internal(ic, &pkt1);
2390         if (ret == AVERROR(EAGAIN))
2391             continue;
2392
2393         if (ret < 0) {
2394             /* EOF or error*/
2395             AVPacket empty_pkt = { 0 };
2396             int err;
2397             av_init_packet(&empty_pkt);
2398
2399             ret = -1; /* we could not have all the codec parameters before EOF */
2400             for(i=0;i<ic->nb_streams;i++) {
2401                 st = ic->streams[i];
2402
2403                 /* flush the decoders */
2404                 while ((err = try_decode_frame(st, &empty_pkt,
2405                                                (options && i < orig_nb_streams) ?
2406                                                 &options[i] : NULL)) >= 0)
2407                     if (has_codec_parameters(st->codec))
2408                         break;
2409
2410                 if (!has_codec_parameters(st->codec)){
2411                     char buf[256];
2412                     avcodec_string(buf, sizeof(buf), st->codec, 0);
2413                     av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2414                 } else {
2415                     ret = 0;
2416                 }
2417             }
2418             break;
2419         }
2420
2421         pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2422         if ((ret = av_dup_packet(pkt)) < 0)
2423             goto find_stream_info_err;
2424
2425         read_size += pkt->size;
2426
2427         st = ic->streams[pkt->stream_index];
2428         if (st->codec_info_nb_frames>1) {
2429             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) {
2430                 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2431                 break;
2432             }
2433             st->info->codec_info_duration += pkt->duration;
2434         }
2435         {
2436             int64_t last = st->info->last_dts;
2437
2438             if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
2439                 int64_t duration= pkt->dts - last;
2440                 double dur= duration * av_q2d(st->time_base);
2441
2442 //                if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2443 //                    av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2444                 if (st->info->duration_count < 2)
2445                     memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2446                 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2447                     int framerate= get_std_framerate(i);
2448                     int ticks= lrintf(dur*framerate/(1001*12));
2449                     double error = dur - (double)ticks*1001*12 / framerate;
2450                     st->info->duration_error[i] += error*error;
2451                 }
2452                 st->info->duration_count++;
2453                 // ignore the first 4 values, they might have some random jitter
2454                 if (st->info->duration_count > 3)
2455                     st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2456             }
2457             if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2458                 st->info->last_dts = pkt->dts;
2459         }
2460         if(st->parser && st->parser->parser->split && !st->codec->extradata){
2461             int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2462             if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2463                 st->codec->extradata_size= i;
2464                 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2465                 if (!st->codec->extradata)
2466                     return AVERROR(ENOMEM);
2467                 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2468                 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2469             }
2470         }
2471
2472         /* if still no information, we try to open the codec and to
2473            decompress the frame. We try to avoid that in most cases as
2474            it takes longer and uses more memory. For MPEG-4, we need to
2475            decompress for QuickTime.
2476
2477            If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2478            least one frame of codec data, this makes sure the codec initializes
2479            the channel configuration and does not only trust the values from the container.
2480         */
2481         try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2482
2483         st->codec_info_nb_frames++;
2484         count++;
2485     }
2486
2487     // close codecs which were opened in try_decode_frame()
2488     for(i=0;i<ic->nb_streams;i++) {
2489         st = ic->streams[i];
2490         if(st->codec->codec)
2491             avcodec_close(st->codec);
2492     }
2493     for(i=0;i<ic->nb_streams;i++) {
2494         st = ic->streams[i];
2495         if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2496             av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2497                      (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2498                       st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2499         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2500             // the check for tb_unreliable() is not completely correct, since this is not about handling
2501             // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2502             // ipmovie.c produces.
2503             if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2504                 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);
2505             if (st->info->duration_count && !st->r_frame_rate.num
2506                && tb_unreliable(st->codec) /*&&
2507                //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2508                st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2509                 int num = 0;
2510                 double best_error= 2*av_q2d(st->time_base);
2511                 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2512
2513                 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2514                     double error = st->info->duration_error[j] * get_std_framerate(j);
2515 //                    if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2516 //                        av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2517                     if(error < best_error){
2518                         best_error= error;
2519                         num = get_std_framerate(j);
2520                     }
2521                 }
2522                 // do not increase frame rate by more than 1 % in order to match a standard rate.
2523                 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2524                     av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2525             }
2526
2527             if (!st->r_frame_rate.num){
2528                 if(    st->codec->time_base.den * (int64_t)st->time_base.num
2529                     <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2530                     st->r_frame_rate.num = st->codec->time_base.den;
2531                     st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2532                 }else{
2533                     st->r_frame_rate.num = st->time_base.den;
2534                     st->r_frame_rate.den = st->time_base.num;
2535                 }
2536             }
2537         }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2538             if(!st->codec->bits_per_coded_sample)
2539                 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2540             // set stream disposition based on audio service type
2541             switch (st->codec->audio_service_type) {
2542             case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2543                 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS;    break;
2544             case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2545                 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED;  break;
2546             case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2547                 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2548             case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2549                 st->disposition = AV_DISPOSITION_COMMENT;          break;
2550             case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2551                 st->disposition = AV_DISPOSITION_KARAOKE;          break;
2552             }
2553         }
2554     }
2555
2556     estimate_timings(ic, old_offset);
2557
2558     compute_chapters_end(ic);
2559
2560 #if 0
2561     /* correct DTS for B-frame streams with no timestamps */
2562     for(i=0;i<ic->nb_streams;i++) {
2563         st = ic->streams[i];
2564         if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2565             if(b-frames){
2566                 ppktl = &ic->packet_buffer;
2567                 while(ppkt1){
2568                     if(ppkt1->stream_index != i)
2569                         continue;
2570                     if(ppkt1->pkt->dts < 0)
2571                         break;
2572                     if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2573                         break;
2574                     ppkt1->pkt->dts -= delta;
2575                     ppkt1= ppkt1->next;
2576                 }
2577                 if(ppkt1)
2578                     continue;
2579                 st->cur_dts -= delta;
2580             }
2581         }
2582     }
2583 #endif
2584
2585  find_stream_info_err:
2586     for (i=0; i < ic->nb_streams; i++) {
2587         if (ic->streams[i]->codec)
2588             ic->streams[i]->codec->thread_count = 0;
2589         av_freep(&ic->streams[i]->info);
2590     }
2591     return ret;
2592 }
2593
2594 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2595 {
2596     int i, j;
2597
2598     for (i = 0; i < ic->nb_programs; i++)
2599         for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2600             if (ic->programs[i]->stream_index[j] == s)
2601                 return ic->programs[i];
2602     return NULL;
2603 }
2604
2605 int av_find_best_stream(AVFormatContext *ic,
2606                         enum AVMediaType type,
2607                         int wanted_stream_nb,
2608                         int related_stream,
2609                         AVCodec **decoder_ret,
2610                         int flags)
2611 {
2612     int i, nb_streams = ic->nb_streams;
2613     int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2614     unsigned *program = NULL;
2615     AVCodec *decoder = NULL, *best_decoder = NULL;
2616
2617     if (related_stream >= 0 && wanted_stream_nb < 0) {
2618         AVProgram *p = find_program_from_stream(ic, related_stream);
2619         if (p) {
2620             program = p->stream_index;
2621             nb_streams = p->nb_stream_indexes;
2622         }
2623     }
2624     for (i = 0; i < nb_streams; i++) {
2625         int real_stream_index = program ? program[i] : i;
2626         AVStream *st = ic->streams[real_stream_index];
2627         AVCodecContext *avctx = st->codec;
2628         if (avctx->codec_type != type)
2629             continue;
2630         if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2631             continue;
2632         if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2633             continue;
2634         if (decoder_ret) {
2635             decoder = avcodec_find_decoder(st->codec->codec_id);
2636             if (!decoder) {
2637                 if (ret < 0)
2638                     ret = AVERROR_DECODER_NOT_FOUND;
2639                 continue;
2640             }
2641         }
2642         if (best_count >= st->codec_info_nb_frames)
2643             continue;
2644         best_count = st->codec_info_nb_frames;
2645         ret = real_stream_index;
2646         best_decoder = decoder;
2647         if (program && i == nb_streams - 1 && ret < 0) {
2648             program = NULL;
2649             nb_streams = ic->nb_streams;
2650             i = 0; /* no related stream found, try again with everything */
2651         }
2652     }
2653     if (decoder_ret)
2654         *decoder_ret = best_decoder;
2655     return ret;
2656 }
2657
2658 /*******************************************************/
2659
2660 int av_read_play(AVFormatContext *s)
2661 {
2662     if (s->iformat->read_play)
2663         return s->iformat->read_play(s);
2664     if (s->pb)
2665         return avio_pause(s->pb, 0);
2666     return AVERROR(ENOSYS);
2667 }
2668
2669 int av_read_pause(AVFormatContext *s)
2670 {
2671     if (s->iformat->read_pause)
2672         return s->iformat->read_pause(s);
2673     if (s->pb)
2674         return avio_pause(s->pb, 1);
2675     return AVERROR(ENOSYS);
2676 }
2677
2678 #if FF_API_FORMAT_PARAMETERS
2679 void av_close_input_stream(AVFormatContext *s)
2680 {
2681     flush_packet_queue(s);
2682     if (s->iformat->read_close)
2683         s->iformat->read_close(s);
2684     avformat_free_context(s);
2685 }
2686 #endif
2687
2688 void avformat_free_context(AVFormatContext *s)
2689 {
2690     int i;
2691     AVStream *st;
2692
2693     av_opt_free(s);
2694     if (s->iformat && s->iformat->priv_class && s->priv_data)
2695         av_opt_free(s->priv_data);
2696
2697     for(i=0;i<s->nb_streams;i++) {
2698         /* free all data in a stream component */
2699         st = s->streams[i];
2700         if (st->parser) {
2701             av_parser_close(st->parser);
2702             av_free_packet(&st->cur_pkt);
2703         }
2704         av_dict_free(&st->metadata);
2705         av_free(st->index_entries);
2706         av_free(st->codec->extradata);
2707         av_free(st->codec->subtitle_header);
2708         av_free(st->codec);
2709         av_free(st->priv_data);
2710         av_free(st->info);
2711         av_free(st);
2712     }
2713     for(i=s->nb_programs-1; i>=0; i--) {
2714         av_dict_free(&s->programs[i]->metadata);
2715         av_freep(&s->programs[i]->stream_index);
2716         av_freep(&s->programs[i]);
2717     }
2718     av_freep(&s->programs);
2719     av_freep(&s->priv_data);
2720     while(s->nb_chapters--) {
2721         av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2722         av_free(s->chapters[s->nb_chapters]);
2723     }
2724     av_freep(&s->chapters);
2725     av_dict_free(&s->metadata);
2726     av_freep(&s->streams);
2727     av_free(s);
2728 }
2729
2730 #if FF_API_CLOSE_INPUT_FILE
2731 void av_close_input_file(AVFormatContext *s)
2732 {
2733     avformat_close_input(&s);
2734 }
2735 #endif
2736
2737 void avformat_close_input(AVFormatContext **ps)
2738 {
2739     AVFormatContext *s = *ps;
2740     AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2741                        NULL : s->pb;
2742     flush_packet_queue(s);
2743     if (s->iformat->read_close)
2744         s->iformat->read_close(s);
2745     avformat_free_context(s);
2746     *ps = NULL;
2747     if (pb)
2748         avio_close(pb);
2749 }
2750
2751 #if FF_API_NEW_STREAM
2752 AVStream *av_new_stream(AVFormatContext *s, int id)
2753 {
2754     AVStream *st = avformat_new_stream(s, NULL);
2755     if (st)
2756         st->id = id;
2757     return st;
2758 }
2759 #endif
2760
2761 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2762 {
2763     AVStream *st;
2764     int i;
2765     AVStream **streams;
2766
2767     if (s->nb_streams >= INT_MAX/sizeof(*streams))
2768         return NULL;
2769     streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2770     if (!streams)
2771         return NULL;
2772     s->streams = streams;
2773
2774     st = av_mallocz(sizeof(AVStream));
2775     if (!st)
2776         return NULL;
2777     if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2778         av_free(st);
2779         return NULL;
2780     }
2781
2782     st->codec = avcodec_alloc_context3(c);
2783     if (s->iformat) {
2784         /* no default bitrate if decoding */
2785         st->codec->bit_rate = 0;
2786     }
2787     st->index = s->nb_streams;
2788     st->start_time = AV_NOPTS_VALUE;
2789     st->duration = AV_NOPTS_VALUE;
2790         /* we set the current DTS to 0 so that formats without any timestamps
2791            but durations get some timestamps, formats with some unknown
2792            timestamps have their first few packets buffered and the
2793            timestamps corrected before they are returned to the user */
2794     st->cur_dts = 0;
2795     st->first_dts = AV_NOPTS_VALUE;
2796     st->probe_packets = MAX_PROBE_PACKETS;
2797
2798     /* default pts setting is MPEG-like */
2799     avpriv_set_pts_info(st, 33, 1, 90000);
2800     st->last_IP_pts = AV_NOPTS_VALUE;
2801     for(i=0; i<MAX_REORDER_DELAY+1; i++)
2802         st->pts_buffer[i]= AV_NOPTS_VALUE;
2803     st->reference_dts = AV_NOPTS_VALUE;
2804
2805     st->sample_aspect_ratio = (AVRational){0,1};
2806
2807     s->streams[s->nb_streams++] = st;
2808     return st;
2809 }
2810
2811 AVProgram *av_new_program(AVFormatContext *ac, int id)
2812 {
2813     AVProgram *program=NULL;
2814     int i;
2815
2816     av_dlog(ac, "new_program: id=0x%04x\n", id);
2817
2818     for(i=0; i<ac->nb_programs; i++)
2819         if(ac->programs[i]->id == id)
2820             program = ac->programs[i];
2821
2822     if(!program){
2823         program = av_mallocz(sizeof(AVProgram));
2824         if (!program)
2825             return NULL;
2826         dynarray_add(&ac->programs, &ac->nb_programs, program);
2827         program->discard = AVDISCARD_NONE;
2828     }
2829     program->id = id;
2830
2831     return program;
2832 }
2833
2834 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2835 {
2836     AVChapter *chapter = NULL;
2837     int i;
2838
2839     for(i=0; i<s->nb_chapters; i++)
2840         if(s->chapters[i]->id == id)
2841             chapter = s->chapters[i];
2842
2843     if(!chapter){
2844         chapter= av_mallocz(sizeof(AVChapter));
2845         if(!chapter)
2846             return NULL;
2847         dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2848     }
2849     av_dict_set(&chapter->metadata, "title", title, 0);
2850     chapter->id    = id;
2851     chapter->time_base= time_base;
2852     chapter->start = start;
2853     chapter->end   = end;
2854
2855     return chapter;
2856 }
2857
2858 /************************************************************/
2859 /* output media file */
2860
2861 #if FF_API_FORMAT_PARAMETERS
2862 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2863 {
2864     int ret;
2865
2866     if (s->oformat->priv_data_size > 0) {
2867         s->priv_data = av_mallocz(s->oformat->priv_data_size);
2868         if (!s->priv_data)
2869             return AVERROR(ENOMEM);
2870         if (s->oformat->priv_class) {
2871             *(const AVClass**)s->priv_data= s->oformat->priv_class;
2872             av_opt_set_defaults(s->priv_data);
2873         }
2874     } else
2875         s->priv_data = NULL;
2876
2877     if (s->oformat->set_parameters) {
2878         ret = s->oformat->set_parameters(s, ap);
2879         if (ret < 0)
2880             return ret;
2881     }
2882     return 0;
2883 }
2884 #endif
2885
2886 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2887 {
2888     const AVCodecTag *avctag;
2889     int n;
2890     enum CodecID id = CODEC_ID_NONE;
2891     unsigned int tag = 0;
2892
2893     /**
2894      * Check that tag + id is in the table
2895      * If neither is in the table -> OK
2896      * If tag is in the table with another id -> FAIL
2897      * If id is in the table with another tag -> FAIL unless strict < normal
2898      */
2899     for (n = 0; s->oformat->codec_tag[n]; n++) {
2900         avctag = s->oformat->codec_tag[n];
2901         while (avctag->id != CODEC_ID_NONE) {
2902             if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
2903                 id = avctag->id;
2904                 if (id == st->codec->codec_id)
2905                     return 1;
2906             }
2907             if (avctag->id == st->codec->codec_id)
2908                 tag = avctag->tag;
2909             avctag++;
2910         }
2911     }
2912     if (id != CODEC_ID_NONE)
2913         return 0;
2914     if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2915         return 0;
2916     return 1;
2917 }
2918
2919 #if FF_API_FORMAT_PARAMETERS
2920 int av_write_header(AVFormatContext *s)
2921 {
2922     return avformat_write_header(s, NULL);
2923 }
2924 #endif
2925
2926 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2927 {
2928     int ret = 0, i;
2929     AVStream *st;
2930     AVDictionary *tmp = NULL;
2931
2932     if (options)
2933         av_dict_copy(&tmp, *options, 0);
2934     if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2935         goto fail;
2936
2937     // some sanity checks
2938     if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2939         av_log(s, AV_LOG_ERROR, "no streams\n");
2940         ret = AVERROR(EINVAL);
2941         goto fail;
2942     }
2943
2944     for(i=0;i<s->nb_streams;i++) {
2945         st = s->streams[i];
2946
2947         switch (st->codec->codec_type) {
2948         case AVMEDIA_TYPE_AUDIO:
2949             if(st->codec->sample_rate<=0){
2950                 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2951                 ret = AVERROR(EINVAL);
2952                 goto fail;
2953             }
2954             if(!st->codec->block_align)
2955                 st->codec->block_align = st->codec->channels *
2956                     av_get_bits_per_sample(st->codec->codec_id) >> 3;
2957             break;
2958         case AVMEDIA_TYPE_VIDEO:
2959             if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2960                 av_log(s, AV_LOG_ERROR, "time base not set\n");
2961                 ret = AVERROR(EINVAL);
2962                 goto fail;
2963             }
2964             if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2965                 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2966                 ret = AVERROR(EINVAL);
2967                 goto fail;
2968             }
2969             if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2970                 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2971                 ret = AVERROR(EINVAL);
2972                 goto fail;
2973             }
2974             break;
2975         }
2976
2977         if(s->oformat->codec_tag){
2978             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)){
2979                 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2980                 st->codec->codec_tag= 0;
2981             }
2982             if(st->codec->codec_tag){
2983                 if (!validate_codec_tag(s, st)) {
2984                     char tagbuf[32];
2985                     av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2986                     av_log(s, AV_LOG_ERROR,
2987                            "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2988                            tagbuf, st->codec->codec_tag, st->codec->codec_id);
2989                     ret = AVERROR_INVALIDDATA;
2990                     goto fail;
2991                 }
2992             }else
2993                 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2994         }
2995
2996         if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2997             !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2998           av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2999     }
3000
3001     if (!s->priv_data && s->oformat->priv_data_size > 0) {
3002         s->priv_data = av_mallocz(s->oformat->priv_data_size);
3003         if (!s->priv_data) {
3004             ret = AVERROR(ENOMEM);
3005             goto fail;
3006         }
3007         if (s->oformat->priv_class) {
3008             *(const AVClass**)s->priv_data= s->oformat->priv_class;
3009             av_opt_set_defaults(s->priv_data);
3010             if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3011                 goto fail;
3012         }
3013     }
3014
3015     /* set muxer identification string */
3016     if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
3017         av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
3018     }
3019
3020     if(s->oformat->write_header){
3021         ret = s->oformat->write_header(s);
3022         if (ret < 0)
3023             goto fail;
3024     }
3025
3026     /* init PTS generation */
3027     for(i=0;i<s->nb_streams;i++) {
3028         int64_t den = AV_NOPTS_VALUE;
3029         st = s->streams[i];
3030
3031         switch (st->codec->codec_type) {
3032         case AVMEDIA_TYPE_AUDIO:
3033             den = (int64_t)st->time_base.num * st->codec->sample_rate;
3034             break;
3035         case AVMEDIA_TYPE_VIDEO:
3036             den = (int64_t)st->time_base.num * st->codec->time_base.den;
3037             break;
3038         default:
3039             break;
3040         }
3041         if (den != AV_NOPTS_VALUE) {
3042             if (den <= 0) {
3043                 ret = AVERROR_INVALIDDATA;
3044                 goto fail;
3045             }
3046             frac_init(&st->pts, 0, 0, den);
3047         }
3048     }
3049
3050     if (options) {
3051         av_dict_free(options);
3052         *options = tmp;
3053     }
3054     return 0;
3055 fail:
3056     av_dict_free(&tmp);
3057     return ret;
3058 }
3059
3060 //FIXME merge with compute_pkt_fields
3061 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3062     int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3063     int num, den, frame_size, i;
3064
3065     av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3066             pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3067
3068 /*    if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
3069         return AVERROR(EINVAL);*/
3070
3071     /* duration field */
3072     if (pkt->duration == 0) {
3073         compute_frame_duration(&num, &den, st, NULL, pkt);
3074         if (den && num) {
3075             pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3076         }
3077     }
3078
3079     if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3080         pkt->pts= pkt->dts;
3081
3082     //XXX/FIXME this is a temporary hack until all encoders output pts
3083     if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3084         pkt->dts=
3085 //        pkt->pts= st->cur_dts;
3086         pkt->pts= st->pts.val;
3087     }
3088
3089     //calculate dts from pts
3090     if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3091         st->pts_buffer[0]= pkt->pts;
3092         for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3093             st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3094         for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3095             FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3096
3097         pkt->dts= st->pts_buffer[0];
3098     }
3099
3100     if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
3101         av_log(s, AV_LOG_ERROR,
3102                "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3103                st->index, st->cur_dts, pkt->dts);
3104         return AVERROR(EINVAL);
3105     }
3106     if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3107         av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3108         return AVERROR(EINVAL);
3109     }
3110
3111 //    av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3112     st->cur_dts= pkt->dts;
3113     st->pts.val= pkt->dts;
3114
3115     /* update pts */
3116     switch (st->codec->codec_type) {
3117     case AVMEDIA_TYPE_AUDIO:
3118         frame_size = get_audio_frame_size(st->codec, pkt->size);
3119
3120         /* HACK/FIXME, we skip the initial 0 size packets as they are most
3121            likely equal to the encoder delay, but it would be better if we
3122            had the real timestamps from the encoder */
3123         if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3124             frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3125         }
3126         break;
3127     case AVMEDIA_TYPE_VIDEO:
3128         frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3129         break;
3130     default:
3131         break;
3132     }
3133     return 0;
3134 }
3135
3136 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3137 {
3138     int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3139
3140     if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3141         return ret;
3142
3143     ret= s->oformat->write_packet(s, pkt);
3144
3145     if (ret >= 0)
3146         s->streams[pkt->stream_index]->nb_frames++;
3147     return ret;
3148 }
3149
3150 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3151                               int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3152 {
3153     AVPacketList **next_point, *this_pktl;
3154
3155     this_pktl = av_mallocz(sizeof(AVPacketList));
3156     this_pktl->pkt= *pkt;
3157     pkt->destruct= NULL;             // do not free original but only the copy
3158     av_dup_packet(&this_pktl->pkt);  // duplicate the packet if it uses non-alloced memory
3159
3160     if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3161         next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3162     }else
3163         next_point = &s->packet_buffer;
3164
3165     if(*next_point){
3166         if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3167             while(!compare(s, &(*next_point)->pkt, pkt)){
3168                 next_point= &(*next_point)->next;
3169             }
3170             goto next_non_null;
3171         }else{
3172             next_point = &(s->packet_buffer_end->next);
3173         }
3174     }
3175     assert(!*next_point);
3176
3177     s->packet_buffer_end= this_pktl;
3178 next_non_null:
3179
3180     this_pktl->next= *next_point;
3181
3182     s->streams[pkt->stream_index]->last_in_packet_buffer=
3183     *next_point= this_pktl;
3184 }
3185
3186 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3187 {
3188     AVStream *st = s->streams[ pkt ->stream_index];
3189     AVStream *st2= s->streams[ next->stream_index];
3190     int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3191                              st->time_base);
3192
3193     if (comp == 0)
3194         return pkt->stream_index < next->stream_index;
3195     return comp > 0;
3196 }
3197
3198 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3199     AVPacketList *pktl;
3200     int stream_count=0;
3201     int i;
3202
3203     if(pkt){
3204         ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3205     }
3206
3207     for(i=0; i < s->nb_streams; i++)
3208         stream_count+= !!s->streams[i]->last_in_packet_buffer;
3209
3210     if(stream_count && (s->nb_streams == stream_count || flush)){
3211         pktl= s->packet_buffer;
3212         *out= pktl->pkt;
3213
3214         s->packet_buffer= pktl->next;
3215         if(!s->packet_buffer)
3216             s->packet_buffer_end= NULL;
3217
3218         if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3219             s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3220         av_freep(&pktl);
3221         return 1;
3222     }else{
3223         av_init_packet(out);
3224         return 0;
3225     }
3226 }
3227
3228 /**
3229  * Interleave an AVPacket correctly so it can be muxed.
3230  * @param out the interleaved packet will be output here
3231  * @param in the input packet
3232  * @param flush 1 if no further packets are available as input and all
3233  *              remaining packets should be output
3234  * @return 1 if a packet was output, 0 if no packet could be output,
3235  *         < 0 if an error occurred
3236  */
3237 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3238     if (s->oformat->interleave_packet) {
3239         int ret = s->oformat->interleave_packet(s, out, in, flush);
3240         if (in)
3241             av_free_packet(in);
3242         return ret;
3243     } else
3244         return av_interleave_packet_per_dts(s, out, in, flush);
3245 }
3246
3247 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3248     AVStream *st= s->streams[ pkt->stream_index];
3249     int ret;
3250
3251     //FIXME/XXX/HACK drop zero sized packets
3252     if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3253         return 0;
3254
3255     av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3256             pkt->size, pkt->dts, pkt->pts);
3257     if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3258         return ret;
3259
3260     if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3261         return AVERROR(EINVAL);
3262
3263     for(;;){
3264         AVPacket opkt;
3265         int ret= interleave_packet(s, &opkt, pkt, 0);
3266         if(ret<=0) //FIXME cleanup needed for ret<0 ?
3267             return ret;
3268
3269         ret= s->oformat->write_packet(s, &opkt);
3270         if (ret >= 0)
3271             s->streams[opkt.stream_index]->nb_frames++;
3272
3273         av_free_packet(&opkt);
3274         pkt= NULL;
3275
3276         if(ret<0)
3277             return ret;
3278     }
3279 }
3280
3281 int av_write_trailer(AVFormatContext *s)
3282 {
3283     int ret, i;
3284
3285     for(;;){
3286         AVPacket pkt;
3287         ret= interleave_packet(s, &pkt, NULL, 1);
3288         if(ret<0) //FIXME cleanup needed for ret<0 ?
3289             goto fail;
3290         if(!ret)
3291             break;
3292
3293         ret= s->oformat->write_packet(s, &pkt);
3294         if (ret >= 0)
3295             s->streams[pkt.stream_index]->nb_frames++;
3296
3297         av_free_packet(&pkt);
3298
3299         if(ret<0)
3300             goto fail;
3301     }
3302
3303     if(s->oformat->write_trailer)
3304         ret = s->oformat->write_trailer(s);
3305 fail:
3306     for(i=0;i<s->nb_streams;i++) {
3307         av_freep(&s->streams[i]->priv_data);
3308         av_freep(&s->streams[i]->index_entries);
3309     }
3310     if (s->oformat->priv_class)
3311         av_opt_free(s->priv_data);
3312     av_freep(&s->priv_data);
3313     return ret;
3314 }
3315
3316 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3317 {
3318     int i, j;
3319     AVProgram *program=NULL;
3320     void *tmp;
3321
3322     if (idx >= ac->nb_streams) {
3323         av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3324         return;
3325     }
3326
3327     for(i=0; i<ac->nb_programs; i++){
3328         if(ac->programs[i]->id != progid)
3329             continue;
3330         program = ac->programs[i];
3331         for(j=0; j<program->nb_stream_indexes; j++)
3332             if(program->stream_index[j] == idx)
3333                 return;
3334
3335         tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3336         if(!tmp)
3337             return;
3338         program->stream_index = tmp;
3339         program->stream_index[program->nb_stream_indexes++] = idx;
3340         return;
3341     }
3342 }
3343
3344 static void print_fps(double d, const char *postfix){
3345     uint64_t v= lrintf(d*100);
3346     if     (v% 100      ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3347     else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3348     else                  av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3349 }
3350
3351 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3352 {
3353     if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3354         AVDictionaryEntry *tag=NULL;
3355
3356         av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3357         while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3358             if(strcmp("language", tag->key))
3359                 av_log(ctx, AV_LOG_INFO, "%s  %-16s: %s\n", indent, tag->key, tag->value);
3360         }
3361     }
3362 }
3363
3364 /* "user interface" functions */
3365 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3366 {
3367     char buf[256];
3368     int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3369     AVStream *st = ic->streams[i];
3370     int g = av_gcd(st->time_base.num, st->time_base.den);
3371     AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3372     avcodec_string(buf, sizeof(buf), st->codec, is_output);
3373     av_log(NULL, AV_LOG_INFO, "    Stream #%d.%d", index, i);
3374     /* the pid is an important information, so we display it */
3375     /* XXX: add a generic system */
3376     if (flags & AVFMT_SHOW_IDS)
3377         av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3378     if (lang)
3379         av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3380     av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3381     av_log(NULL, AV_LOG_INFO, ": %s", buf);
3382     if (st->sample_aspect_ratio.num && // default
3383         av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3384         AVRational display_aspect_ratio;
3385         av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3386                   st->codec->width*st->sample_aspect_ratio.num,
3387                   st->codec->height*st->sample_aspect_ratio.den,
3388                   1024*1024);
3389         av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3390                  st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3391                  display_aspect_ratio.num, display_aspect_ratio.den);
3392     }
3393     if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3394         if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3395             print_fps(av_q2d(st->avg_frame_rate), "fps");
3396         if(st->r_frame_rate.den && st->r_frame_rate.num)
3397             print_fps(av_q2d(st->r_frame_rate), "tbr");
3398         if(st->time_base.den && st->time_base.num)
3399             print_fps(1/av_q2d(st->time_base), "tbn");
3400         if(st->codec->time_base.den && st->codec->time_base.num)
3401             print_fps(1/av_q2d(st->codec->time_base), "tbc");
3402     }
3403     if (st->disposition & AV_DISPOSITION_DEFAULT)
3404         av_log(NULL, AV_LOG_INFO, " (default)");
3405     if (st->disposition & AV_DISPOSITION_DUB)
3406         av_log(NULL, AV_LOG_INFO, " (dub)");
3407     if (st->disposition & AV_DISPOSITION_ORIGINAL)
3408         av_log(NULL, AV_LOG_INFO, " (original)");
3409     if (st->disposition & AV_DISPOSITION_COMMENT)
3410         av_log(NULL, AV_LOG_INFO, " (comment)");
3411     if (st->disposition & AV_DISPOSITION_LYRICS)
3412         av_log(NULL, AV_LOG_INFO, " (lyrics)");
3413     if (st->disposition & AV_DISPOSITION_KARAOKE)
3414         av_log(NULL, AV_LOG_INFO, " (karaoke)");
3415     if (st->disposition & AV_DISPOSITION_FORCED)
3416         av_log(NULL, AV_LOG_INFO, " (forced)");
3417     if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3418         av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3419     if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3420         av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3421     if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3422         av_log(NULL, AV_LOG_INFO, " (clean effects)");
3423     av_log(NULL, AV_LOG_INFO, "\n");
3424     dump_metadata(NULL, st->metadata, "    ");
3425 }
3426
3427 #if FF_API_DUMP_FORMAT
3428 void dump_format(AVFormatContext *ic,
3429                  int index,
3430                  const char *url,
3431                  int is_output)
3432 {
3433     av_dump_format(ic, index, url, is_output);
3434 }
3435 #endif
3436
3437 void av_dump_format(AVFormatContext *ic,
3438                     int index,
3439                     const char *url,
3440                     int is_output)
3441 {
3442     int i;
3443     uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3444     if (ic->nb_streams && !printed)
3445         return;
3446
3447     av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3448             is_output ? "Output" : "Input",
3449             index,
3450             is_output ? ic->oformat->name : ic->iformat->name,
3451             is_output ? "to" : "from", url);
3452     dump_metadata(NULL, ic->metadata, "  ");
3453     if (!is_output) {
3454         av_log(NULL, AV_LOG_INFO, "  Duration: ");
3455         if (ic->duration != AV_NOPTS_VALUE) {
3456             int hours, mins, secs, us;
3457             secs = ic->duration / AV_TIME_BASE;
3458             us = ic->duration % AV_TIME_BASE;
3459             mins = secs / 60;
3460             secs %= 60;
3461             hours = mins / 60;
3462             mins %= 60;
3463             av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3464                    (100 * us) / AV_TIME_BASE);
3465         } else {
3466             av_log(NULL, AV_LOG_INFO, "N/A");
3467         }
3468         if (ic->start_time != AV_NOPTS_VALUE) {
3469             int secs, us;
3470             av_log(NULL, AV_LOG_INFO, ", start: ");
3471             secs = ic->start_time / AV_TIME_BASE;
3472             us = abs(ic->start_time % AV_TIME_BASE);
3473             av_log(NULL, AV_LOG_INFO, "%d.%06d",
3474                    secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3475         }
3476         av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3477         if (ic->bit_rate) {
3478             av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3479         } else {
3480             av_log(NULL, AV_LOG_INFO, "N/A");
3481         }
3482         av_log(NULL, AV_LOG_INFO, "\n");
3483     }
3484     for (i = 0; i < ic->nb_chapters; i++) {
3485         AVChapter *ch = ic->chapters[i];
3486         av_log(NULL, AV_LOG_INFO, "    Chapter #%d.%d: ", index, i);
3487         av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3488         av_log(NULL, AV_LOG_INFO, "end %f\n",   ch->end   * av_q2d(ch->time_base));
3489
3490         dump_metadata(NULL, ch->metadata, "    ");
3491     }
3492     if(ic->nb_programs) {
3493         int j, k, total = 0;
3494         for(j=0; j<ic->nb_programs; j++) {
3495             AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3496                                                   "name", NULL, 0);
3497             av_log(NULL, AV_LOG_INFO, "  Program %d %s\n", ic->programs[j]->id,
3498                    name ? name->value : "");
3499             dump_metadata(NULL, ic->programs[j]->metadata, "    ");
3500             for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3501                 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3502                 printed[ic->programs[j]->stream_index[k]] = 1;
3503             }
3504             total += ic->programs[j]->nb_stream_indexes;
3505         }
3506         if (total < ic->nb_streams)
3507             av_log(NULL, AV_LOG_INFO, "  No Program\n");
3508     }
3509     for(i=0;i<ic->nb_streams;i++)
3510         if (!printed[i])
3511             dump_stream_format(ic, i, index, is_output);
3512
3513     av_free(printed);
3514 }
3515
3516 int64_t av_gettime(void)
3517 {
3518     struct timeval tv;
3519     gettimeofday(&tv,NULL);
3520     return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3521 }
3522
3523 uint64_t ff_ntp_time(void)
3524 {
3525   return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3526 }
3527
3528 #if FF_API_PARSE_DATE
3529 #include "libavutil/parseutils.h"
3530
3531 int64_t parse_date(const char *timestr, int duration)
3532 {
3533     int64_t timeval;
3534     av_parse_time(&timeval, timestr, duration);
3535     return timeval;
3536 }
3537 #endif
3538
3539 #if FF_API_FIND_INFO_TAG
3540 #include "libavutil/parseutils.h"
3541
3542 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3543 {
3544     return av_find_info_tag(arg, arg_size, tag1, info);
3545 }
3546 #endif
3547
3548 int av_get_frame_filename(char *buf, int buf_size,
3549                           const char *path, int number)
3550 {
3551     const char *p;
3552     char *q, buf1[20], c;
3553     int nd, len, percentd_found;
3554
3555     q = buf;
3556     p = path;
3557     percentd_found = 0;
3558     for(;;) {
3559         c = *p++;
3560         if (c == '\0')
3561             break;
3562         if (c == '%') {
3563             do {
3564                 nd = 0;
3565                 while (isdigit(*p)) {
3566                     nd = nd * 10 + *p++ - '0';
3567                 }
3568                 c = *p++;
3569             } while (isdigit(c));
3570
3571             switch(c) {
3572             case '%':
3573                 goto addchar;
3574             case 'd':
3575                 if (percentd_found)
3576                     goto fail;
3577                 percentd_found = 1;
3578                 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3579                 len = strlen(buf1);
3580                 if ((q - buf + len) > buf_size - 1)
3581                     goto fail;
3582                 memcpy(q, buf1, len);
3583                 q += len;
3584                 break;
3585             default:
3586                 goto fail;
3587             }
3588         } else {
3589         addchar:
3590             if ((q - buf) < buf_size - 1)
3591                 *q++ = c;
3592         }
3593     }
3594     if (!percentd_found)
3595         goto fail;
3596     *q = '\0';
3597     return 0;
3598  fail:
3599     *q = '\0';
3600     return -1;
3601 }
3602
3603 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3604 {
3605     int len, i, j, c;
3606 #undef fprintf
3607 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3608
3609     for(i=0;i<size;i+=16) {
3610         len = size - i;
3611         if (len > 16)
3612             len = 16;
3613         PRINT("%08x ", i);
3614         for(j=0;j<16;j++) {
3615             if (j < len)
3616                 PRINT(" %02x", buf[i+j]);
3617             else
3618                 PRINT("   ");
3619         }
3620         PRINT(" ");
3621         for(j=0;j<len;j++) {
3622             c = buf[i+j];
3623             if (c < ' ' || c > '~')
3624                 c = '.';
3625             PRINT("%c", c);
3626         }
3627         PRINT("\n");
3628     }
3629 #undef PRINT
3630 }
3631
3632 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3633 {
3634     hex_dump_internal(NULL, f, 0, buf, size);
3635 }
3636
3637 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3638 {
3639     hex_dump_internal(avcl, NULL, level, buf, size);
3640 }
3641
3642 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3643 {
3644 #undef fprintf
3645 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3646     PRINT("stream #%d:\n", pkt->stream_index);
3647     PRINT("  keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3648     PRINT("  duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3649     /* DTS is _always_ valid after av_read_frame() */
3650     PRINT("  dts=");
3651     if (pkt->dts == AV_NOPTS_VALUE)
3652         PRINT("N/A");
3653     else
3654         PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3655     /* PTS may not be known if B-frames are present. */
3656     PRINT("  pts=");
3657     if (pkt->pts == AV_NOPTS_VALUE)
3658         PRINT("N/A");
3659     else
3660         PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3661     PRINT("\n");
3662     PRINT("  size=%d\n", pkt->size);
3663 #undef PRINT
3664     if (dump_payload)
3665         av_hex_dump(f, pkt->data, pkt->size);
3666 }
3667
3668 #if FF_API_PKT_DUMP
3669 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3670 {
3671     AVRational tb = { 1, AV_TIME_BASE };
3672     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3673 }
3674 #endif
3675
3676 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3677 {
3678     pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3679 }
3680
3681 #if FF_API_PKT_DUMP
3682 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3683 {
3684     AVRational tb = { 1, AV_TIME_BASE };
3685     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3686 }
3687 #endif
3688
3689 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3690                       AVStream *st)
3691 {
3692     pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3693 }
3694
3695 void av_url_split(char *proto, int proto_size,
3696                   char *authorization, int authorization_size,
3697                   char *hostname, int hostname_size,
3698                   int *port_ptr,
3699                   char *path, int path_size,
3700                   const char *url)
3701 {
3702     const char *p, *ls, *at, *col, *brk;
3703
3704     if (port_ptr)               *port_ptr = -1;
3705     if (proto_size > 0)         proto[0] = 0;
3706     if (authorization_size > 0) authorization[0] = 0;
3707     if (hostname_size > 0)      hostname[0] = 0;
3708     if (path_size > 0)          path[0] = 0;
3709
3710     /* parse protocol */
3711     if ((p = strchr(url, ':'))) {
3712         av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3713         p++; /* skip ':' */
3714         if (*p == '/') p++;
3715         if (*p == '/') p++;
3716     } else {
3717         /* no protocol means plain filename */
3718         av_strlcpy(path, url, path_size);
3719         return;
3720     }
3721
3722     /* separate path from hostname */
3723     ls = strchr(p, '/');
3724     if(!ls)
3725         ls = strchr(p, '?');
3726     if(ls)
3727         av_strlcpy(path, ls, path_size);
3728     else
3729         ls = &p[strlen(p)]; // XXX
3730
3731     /* the rest is hostname, use that to parse auth/port */
3732     if (ls != p) {
3733         /* authorization (user[:pass]@hostname) */
3734         if ((at = strchr(p, '@')) && at < ls) {
3735             av_strlcpy(authorization, p,
3736                        FFMIN(authorization_size, at + 1 - p));
3737             p = at + 1; /* skip '@' */
3738         }
3739
3740         if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3741             /* [host]:port */
3742             av_strlcpy(hostname, p + 1,
3743                        FFMIN(hostname_size, brk - p));
3744             if (brk[1] == ':' && port_ptr)
3745                 *port_ptr = atoi(brk + 2);
3746         } else if ((col = strchr(p, ':')) && col < ls) {
3747             av_strlcpy(hostname, p,
3748                        FFMIN(col + 1 - p, hostname_size));
3749             if (port_ptr) *port_ptr = atoi(col + 1);
3750         } else
3751             av_strlcpy(hostname, p,
3752                        FFMIN(ls + 1 - p, hostname_size));
3753     }
3754 }
3755
3756 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3757 {
3758     int i;
3759     static const char hex_table_uc[16] = { '0', '1', '2', '3',
3760                                            '4', '5', '6', '7',
3761                                            '8', '9', 'A', 'B',
3762                                            'C', 'D', 'E', 'F' };
3763     static const char hex_table_lc[16] = { '0', '1', '2', '3',
3764                                            '4', '5', '6', '7',
3765                                            '8', '9', 'a', 'b',
3766                                            'c', 'd', 'e', 'f' };
3767     const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3768
3769     for(i = 0; i < s; i++) {
3770         buff[i * 2]     = hex_table[src[i] >> 4];
3771         buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3772     }
3773
3774     return buff;
3775 }
3776
3777 int ff_hex_to_data(uint8_t *data, const char *p)
3778 {
3779     int c, len, v;
3780
3781     len = 0;
3782     v = 1;
3783     for (;;) {
3784         p += strspn(p, SPACE_CHARS);
3785         if (*p == '\0')
3786             break;
3787         c = toupper((unsigned char) *p++);
3788         if (c >= '0' && c <= '9')
3789             c = c - '0';
3790         else if (c >= 'A' && c <= 'F')
3791             c = c - 'A' + 10;
3792         else
3793             break;
3794         v = (v << 4) | c;
3795         if (v & 0x100) {
3796             if (data)
3797                 data[len] = v;
3798             len++;
3799             v = 1;
3800         }
3801     }
3802     return len;
3803 }
3804
3805 #if FF_API_SET_PTS_INFO
3806 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3807                      unsigned int pts_num, unsigned int pts_den)
3808 {
3809     avpriv_set_pts_info(s, pts_wrap_bits, pts_num, pts_den);
3810 }
3811 #endif
3812
3813 void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
3814                          unsigned int pts_num, unsigned int pts_den)
3815 {
3816     AVRational new_tb;
3817     if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3818         if(new_tb.num != pts_num)
3819             av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3820     }else
3821         av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3822
3823     if(new_tb.num <= 0 || new_tb.den <= 0) {
3824         av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3825         return;
3826     }
3827     s->time_base = new_tb;
3828     s->pts_wrap_bits = pts_wrap_bits;
3829 }
3830
3831 int ff_url_join(char *str, int size, const char *proto,
3832                 const char *authorization, const char *hostname,
3833                 int port, const char *fmt, ...)
3834 {
3835 #if CONFIG_NETWORK
3836     struct addrinfo hints, *ai;
3837 #endif
3838
3839     str[0] = '\0';
3840     if (proto)
3841         av_strlcatf(str, size, "%s://", proto);
3842     if (authorization && authorization[0])
3843         av_strlcatf(str, size, "%s@", authorization);
3844 #if CONFIG_NETWORK && defined(AF_INET6)
3845     /* Determine if hostname is a numerical IPv6 address,
3846      * properly escape it within [] in that case. */
3847     memset(&hints, 0, sizeof(hints));
3848     hints.ai_flags = AI_NUMERICHOST;
3849     if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3850         if (ai->ai_family == AF_INET6) {
3851             av_strlcat(str, "[", size);
3852             av_strlcat(str, hostname, size);
3853             av_strlcat(str, "]", size);
3854         } else {
3855             av_strlcat(str, hostname, size);
3856         }
3857         freeaddrinfo(ai);
3858     } else
3859 #endif
3860         /* Not an IPv6 address, just output the plain string. */
3861         av_strlcat(str, hostname, size);
3862
3863     if (port >= 0)
3864         av_strlcatf(str, size, ":%d", port);
3865     if (fmt) {
3866         va_list vl;
3867         int len = strlen(str);
3868
3869         va_start(vl, fmt);
3870         vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3871         va_end(vl);
3872     }
3873     return strlen(str);
3874 }
3875
3876 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3877                      AVFormatContext *src)
3878 {
3879     AVPacket local_pkt;
3880
3881     local_pkt = *pkt;
3882     local_pkt.stream_index = dst_stream;
3883     if (pkt->pts != AV_NOPTS_VALUE)
3884         local_pkt.pts = av_rescale_q(pkt->pts,
3885                                      src->streams[pkt->stream_index]->time_base,
3886                                      dst->streams[dst_stream]->time_base);
3887     if (pkt->dts != AV_NOPTS_VALUE)
3888         local_pkt.dts = av_rescale_q(pkt->dts,
3889                                      src->streams[pkt->stream_index]->time_base,
3890                                      dst->streams[dst_stream]->time_base);
3891     return av_write_frame(dst, &local_pkt);
3892 }
3893
3894 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3895                         void *context)
3896 {
3897     const char *ptr = str;
3898
3899     /* Parse key=value pairs. */
3900     for (;;) {
3901         const char *key;
3902         char *dest = NULL, *dest_end;
3903         int key_len, dest_len = 0;
3904
3905         /* Skip whitespace and potential commas. */
3906         while (*ptr && (isspace(*ptr) || *ptr == ','))
3907             ptr++;
3908         if (!*ptr)
3909             break;
3910
3911         key = ptr;
3912
3913         if (!(ptr = strchr(key, '=')))
3914             break;
3915         ptr++;
3916         key_len = ptr - key;
3917
3918         callback_get_buf(context, key, key_len, &dest, &dest_len);
3919         dest_end = dest + dest_len - 1;
3920
3921         if (*ptr == '\"') {
3922             ptr++;
3923             while (*ptr && *ptr != '\"') {
3924                 if (*ptr == '\\') {
3925                     if (!ptr[1])
3926                         break;
3927                     if (dest && dest < dest_end)
3928                         *dest++ = ptr[1];
3929                     ptr += 2;
3930                 } else {
3931                     if (dest && dest < dest_end)
3932                         *dest++ = *ptr;
3933                     ptr++;
3934                 }
3935             }
3936             if (*ptr == '\"')
3937                 ptr++;
3938         } else {
3939             for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3940                 if (dest && dest < dest_end)
3941                     *dest++ = *ptr;
3942         }
3943         if (dest)
3944             *dest = 0;
3945     }
3946 }
3947
3948 int ff_find_stream_index(AVFormatContext *s, int id)
3949 {
3950     int i;
3951     for (i = 0; i < s->nb_streams; i++) {
3952         if (s->streams[i]->id == id)
3953             return i;
3954     }
3955     return -1;
3956 }
3957
3958 void ff_make_absolute_url(char *buf, int size, const char *base,
3959                           const char *rel)
3960 {
3961     char *sep;
3962     /* Absolute path, relative to the current server */
3963     if (base && strstr(base, "://") && rel[0] == '/') {
3964         if (base != buf)
3965             av_strlcpy(buf, base, size);
3966         sep = strstr(buf, "://");
3967         if (sep) {
3968             sep += 3;
3969             sep = strchr(sep, '/');
3970             if (sep)
3971                 *sep = '\0';
3972         }
3973         av_strlcat(buf, rel, size);
3974         return;
3975     }
3976     /* If rel actually is an absolute url, just copy it */
3977     if (!base || strstr(rel, "://") || rel[0] == '/') {
3978         av_strlcpy(buf, rel, size);
3979         return;
3980     }
3981     if (base != buf)
3982         av_strlcpy(buf, base, size);
3983     /* Remove the file name from the base url */
3984     sep = strrchr(buf, '/');
3985     if (sep)
3986         sep[1] = '\0';
3987     else
3988         buf[0] = '\0';
3989     while (av_strstart(rel, "../", NULL) && sep) {
3990         /* Remove the path delimiter at the end */
3991         sep[0] = '\0';
3992         sep = strrchr(buf, '/');
3993         /* If the next directory name to pop off is "..", break here */
3994         if (!strcmp(sep ? &sep[1] : buf, "..")) {
3995             /* Readd the slash we just removed */
3996             av_strlcat(buf, "/", size);
3997             break;
3998         }
3999         /* Cut off the directory name */
4000         if (sep)
4001             sep[1] = '\0';
4002         else
4003             buf[0] = '\0';
4004         rel += 3;
4005     }
4006     av_strlcat(buf, rel, size);
4007 }
4008
4009 int64_t ff_iso8601_to_unix_time(const char *datestr)
4010 {
4011 #if HAVE_STRPTIME
4012     struct tm time1 = {0}, time2 = {0};
4013     char *ret1, *ret2;
4014     ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
4015     ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
4016     if (ret2 && !ret1)
4017         return av_timegm(&time2);
4018     else
4019         return av_timegm(&time1);
4020 #else
4021     av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
4022                                  "the date string.\n");
4023     return 0;
4024 #endif
4025 }
4026
4027 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
4028 {
4029     if (ofmt) {
4030         if (ofmt->query_codec)
4031             return ofmt->query_codec(codec_id, std_compliance);
4032         else if (ofmt->codec_tag)
4033             return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4034         else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4035                  codec_id == ofmt->subtitle_codec)
4036             return 1;
4037     }
4038     return AVERROR_PATCHWELCOME;
4039 }
4040
4041 int avformat_network_init(void)
4042 {
4043 #if CONFIG_NETWORK
4044     int ret;
4045     ff_network_inited_globally = 1;
4046     if ((ret = ff_network_init()) < 0)
4047         return ret;
4048     ff_tls_init();
4049 #endif
4050     return 0;
4051 }
4052
4053 int avformat_network_deinit(void)
4054 {
4055 #if CONFIG_NETWORK
4056     ff_network_close();
4057     ff_tls_deinit();
4058 #endif
4059     return 0;
4060 }
4061
4062 int ff_add_param_change(AVPacket *pkt, int32_t channels,
4063                         uint64_t channel_layout, int32_t sample_rate,
4064                         int32_t width, int32_t height)
4065 {
4066     uint32_t flags = 0;
4067     int size = 4;
4068     uint8_t *data;
4069     if (!pkt)
4070         return AVERROR(EINVAL);
4071     if (channels) {
4072         size += 4;
4073         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT;
4074     }
4075     if (channel_layout) {
4076         size += 8;
4077         flags |= AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT;
4078     }
4079     if (sample_rate) {
4080         size += 4;
4081         flags |= AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE;
4082     }
4083     if (width || height) {
4084         size += 8;
4085         flags |= AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS;
4086     }
4087     data = av_packet_new_side_data(pkt, AV_PKT_DATA_PARAM_CHANGE, size);
4088     if (!data)
4089         return AVERROR(ENOMEM);
4090     bytestream_put_le32(&data, flags);
4091     if (channels)
4092         bytestream_put_le32(&data, channels);
4093     if (channel_layout)
4094         bytestream_put_le64(&data, channel_layout);
4095     if (sample_rate)
4096         bytestream_put_le32(&data, sample_rate);
4097     if (width || height) {
4098         bytestream_put_le32(&data, width);
4099         bytestream_put_le32(&data, height);
4100     }
4101     return 0;
4102 }