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