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