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