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