2 * various utility functions for use within Libav
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of Libav.
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.
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.
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
25 #include "avio_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"
34 #include "libavutil/avassert.h"
35 #include "libavutil/avstring.h"
36 #include "libavutil/mathematics.h"
37 #include "libavutil/parseutils.h"
39 #include "audiointerleave.h"
53 * various utility functions for use within Libav
56 unsigned avformat_version(void)
58 return LIBAVFORMAT_VERSION_INT;
61 const char *avformat_configuration(void)
63 return LIBAV_CONFIGURATION;
66 const char *avformat_license(void)
68 #define LICENSE_PREFIX "libavformat license: "
69 return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
72 /* fraction handling */
75 * f = val + (num / den) + 0.5.
77 * 'num' is normalized so that it is such as 0 <= num < den.
79 * @param f fractional number
80 * @param val integer value
81 * @param num must be >= 0
82 * @param den must be >= 1
84 static void frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
97 * Fractional addition to f: f = f + (incr / f->den).
99 * @param f fractional number
100 * @param incr increment, can be positive or negative
102 static void frac_add(AVFrac *f, int64_t incr)
115 } else if (num >= den) {
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;
127 AVInputFormat *av_iformat_next(AVInputFormat *f)
129 if(f) return f->next;
130 else return first_iformat;
133 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
135 if(f) return f->next;
136 else return first_oformat;
139 void av_register_input_format(AVInputFormat *format)
143 while (*p != NULL) p = &(*p)->next;
148 void av_register_output_format(AVOutputFormat *format)
152 while (*p != NULL) p = &(*p)->next;
157 int av_match_ext(const char *filename, const char *extensions)
165 ext = strrchr(filename, '.');
171 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
174 if (!av_strcasecmp(ext1, ext))
184 static int match_format(const char *name, const char *names)
192 namelen = strlen(name);
193 while ((p = strchr(names, ','))) {
194 len = FFMAX(p - names, namelen);
195 if (!av_strncasecmp(name, names, len))
199 return !av_strcasecmp(name, names);
202 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
203 const char *mime_type)
205 AVOutputFormat *fmt = NULL, *fmt_found;
206 int score_max, score;
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);
216 /* Find the proper file type. */
219 while ((fmt = av_oformat_next(fmt))) {
221 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
223 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
225 if (filename && fmt->extensions &&
226 av_match_ext(filename, fmt->extensions)) {
229 if (score > score_max) {
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;
242 #if CONFIG_IMAGE2_MUXER
243 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
244 codec_id= ff_guess_image2_codec(filename);
247 if(codec_id == CODEC_ID_NONE)
248 codec_id= fmt->video_codec;
250 }else if(type == AVMEDIA_TYPE_AUDIO)
251 return fmt->audio_codec;
252 else if (type == AVMEDIA_TYPE_SUBTITLE)
253 return fmt->subtitle_codec;
255 return CODEC_ID_NONE;
258 AVInputFormat *av_find_input_format(const char *short_name)
260 AVInputFormat *fmt = NULL;
261 while ((fmt = av_iformat_next(fmt))) {
262 if (match_format(short_name, fmt->name))
269 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
271 int ret= av_new_packet(pkt, size);
276 pkt->pos= avio_tell(s);
278 ret= avio_read(s, pkt->data, size);
282 av_shrink_packet(pkt, ret);
287 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
292 return av_get_packet(s, pkt, size);
293 old_size = pkt->size;
294 ret = av_grow_packet(pkt, size);
297 ret = avio_read(s, pkt->data + old_size, size);
298 av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
303 int av_filename_number_test(const char *filename)
306 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
309 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
311 AVProbeData lpd = *pd;
312 AVInputFormat *fmt1 = NULL, *fmt;
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) {
319 lpd.buf_size -= id3len;
325 while ((fmt1 = av_iformat_next(fmt1))) {
326 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
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)) {
336 if (score > *score_max) {
339 }else if (score == *score_max)
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;
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;
363 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
365 return av_probe_input_format2(pd, is_opened, &score);
368 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
370 static const struct {
371 const char *name; enum CodecID id; enum AVMediaType 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 },
383 AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
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;
400 /************************************************************/
401 /* input media file */
403 #if FF_API_FORMAT_PARAMETERS
404 static AVDictionary *convert_format_parameters(AVFormatParameters *ap)
407 AVDictionary *opts = NULL;
412 if (ap->time_base.num) {
413 snprintf(buf, sizeof(buf), "%d/%d", ap->time_base.den, ap->time_base.num);
414 av_dict_set(&opts, "framerate", buf, 0);
416 if (ap->sample_rate) {
417 snprintf(buf, sizeof(buf), "%d", ap->sample_rate);
418 av_dict_set(&opts, "sample_rate", buf, 0);
421 snprintf(buf, sizeof(buf), "%d", ap->channels);
422 av_dict_set(&opts, "channels", buf, 0);
424 if (ap->width || ap->height) {
425 snprintf(buf, sizeof(buf), "%dx%d", ap->width, ap->height);
426 av_dict_set(&opts, "video_size", buf, 0);
428 if (ap->pix_fmt != PIX_FMT_NONE) {
429 av_dict_set(&opts, "pixel_format", av_get_pix_fmt_name(ap->pix_fmt), 0);
432 snprintf(buf, sizeof(buf), "%d", ap->channel);
433 av_dict_set(&opts, "channel", buf, 0);
436 av_dict_set(&opts, "standard", ap->standard, 0);
438 if (ap->mpeg2ts_compute_pcr) {
439 av_dict_set(&opts, "mpeg2ts_compute_pcr", "1", 0);
441 if (ap->initial_pause) {
442 av_dict_set(&opts, "initial_pause", "1", 0);
448 * Open a media file from an IO stream. 'fmt' must be specified.
450 int av_open_input_stream(AVFormatContext **ic_ptr,
451 AVIOContext *pb, const char *filename,
452 AVInputFormat *fmt, AVFormatParameters *ap)
457 AVFormatParameters default_ap;
461 memset(ap, 0, sizeof(default_ap));
463 opts = convert_format_parameters(ap);
465 if(!ap->prealloced_context)
466 ic = avformat_alloc_context();
470 err = AVERROR(ENOMEM);
473 if (pb && fmt && fmt->flags & AVFMT_NOFILE)
474 av_log(ic, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
475 "will be ignored with AVFMT_NOFILE format.\n");
479 if ((err = avformat_open_input(&ic, filename, fmt, &opts)) < 0)
481 ic->pb = ic->pb ? ic->pb : pb; // don't leak custom pb if it wasn't set above
490 /** size of probe buffer, for guessing file type from file contents */
491 #define PROBE_BUF_MIN 2048
492 #define PROBE_BUF_MAX (1<<20)
494 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
495 const char *filename, void *logctx,
496 unsigned int offset, unsigned int max_probe_size)
498 AVProbeData pd = { filename ? filename : "", NULL, -offset };
499 unsigned char *buf = NULL;
500 int ret = 0, probe_size;
502 if (!max_probe_size) {
503 max_probe_size = PROBE_BUF_MAX;
504 } else if (max_probe_size > PROBE_BUF_MAX) {
505 max_probe_size = PROBE_BUF_MAX;
506 } else if (max_probe_size < PROBE_BUF_MIN) {
507 return AVERROR(EINVAL);
510 if (offset >= max_probe_size) {
511 return AVERROR(EINVAL);
514 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
515 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
516 int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
517 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
519 if (probe_size < offset) {
523 /* read probe data */
524 buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
525 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
526 /* fail if error was not end of file, otherwise, lower score */
527 if (ret != AVERROR_EOF) {
532 ret = 0; /* error was end of file, nothing read */
535 pd.buf = &buf[offset];
537 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
539 /* guess file format */
540 *fmt = av_probe_input_format2(&pd, 1, &score);
542 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
543 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
545 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
551 return AVERROR_INVALIDDATA;
554 /* rewind. reuse probe buffer to avoid seeking */
555 if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
561 #if FF_API_FORMAT_PARAMETERS
562 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
565 AVFormatParameters *ap)
568 AVDictionary *opts = convert_format_parameters(ap);
570 if (!ap || !ap->prealloced_context)
573 err = avformat_open_input(ic_ptr, filename, fmt, &opts);
580 /* open input file and probe the format if necessary */
581 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
584 AVProbeData pd = {filename, NULL, 0};
587 s->flags |= AVFMT_FLAG_CUSTOM_IO;
589 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
590 else if (s->iformat->flags & AVFMT_NOFILE)
591 return AVERROR(EINVAL);
595 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
596 (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
599 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ,
600 &s->interrupt_callback, options)) < 0)
604 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
607 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
609 AVFormatContext *s = *ps;
611 AVFormatParameters ap = { { 0 } };
612 AVDictionary *tmp = NULL;
614 if (!s && !(s = avformat_alloc_context()))
615 return AVERROR(ENOMEM);
620 av_dict_copy(&tmp, *options, 0);
622 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
625 if ((ret = init_input(s, filename, &tmp)) < 0)
628 /* check filename in case an image number is expected */
629 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
630 if (!av_filename_number_test(filename)) {
631 ret = AVERROR(EINVAL);
636 s->duration = s->start_time = AV_NOPTS_VALUE;
637 av_strlcpy(s->filename, filename, sizeof(s->filename));
639 /* allocate private data */
640 if (s->iformat->priv_data_size > 0) {
641 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
642 ret = AVERROR(ENOMEM);
645 if (s->iformat->priv_class) {
646 *(const AVClass**)s->priv_data = s->iformat->priv_class;
647 av_opt_set_defaults(s->priv_data);
648 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
653 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
655 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC);
657 if (s->iformat->read_header)
658 if ((ret = s->iformat->read_header(s, &ap)) < 0)
661 if (s->pb && !s->data_offset)
662 s->data_offset = avio_tell(s->pb);
664 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
667 av_dict_free(options);
675 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
677 avformat_free_context(s);
682 /*******************************************************/
684 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
685 AVPacketList **plast_pktl){
686 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
691 (*plast_pktl)->next = pktl;
693 *packet_buffer = pktl;
695 /* add the packet in the buffered packet list */
701 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
707 AVPacketList *pktl = s->raw_packet_buffer;
711 if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
712 !s->streams[pkt->stream_index]->probe_packets ||
713 s->raw_packet_buffer_remaining_size < pkt->size){
714 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
717 s->raw_packet_buffer = pktl->next;
718 s->raw_packet_buffer_remaining_size += pkt->size;
725 ret= s->iformat->read_packet(s, pkt);
727 if (!pktl || ret == AVERROR(EAGAIN))
729 for (i = 0; i < s->nb_streams; i++)
730 s->streams[i]->probe_packets = 0;
734 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
735 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
736 av_log(s, AV_LOG_WARNING,
737 "Dropped corrupted packet (stream = %d)\n",
743 st= s->streams[pkt->stream_index];
745 switch(st->codec->codec_type){
746 case AVMEDIA_TYPE_VIDEO:
747 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
749 case AVMEDIA_TYPE_AUDIO:
750 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
752 case AVMEDIA_TYPE_SUBTITLE:
753 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
757 if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
761 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
762 s->raw_packet_buffer_remaining_size -= pkt->size;
764 if(st->codec->codec_id == CODEC_ID_PROBE){
765 AVProbeData *pd = &st->probe_data;
766 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
769 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
770 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
771 pd->buf_size += pkt->size;
772 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
774 if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
775 //FIXME we do not reduce score to 0 for the case of running out of buffer space in bytes
776 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
777 if(st->codec->codec_id != CODEC_ID_PROBE){
780 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
787 /**********************************************************/
790 * Get the number of samples of an audio frame. Return -1 on error.
792 static int get_audio_frame_size(AVCodecContext *enc, int size)
796 if(enc->codec_id == CODEC_ID_VORBIS)
799 if (enc->frame_size <= 1) {
800 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
802 if (bits_per_sample) {
803 if (enc->channels == 0)
805 frame_size = (size << 3) / (bits_per_sample * enc->channels);
807 /* used for example by ADPCM codecs */
808 if (enc->bit_rate == 0)
810 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
813 frame_size = enc->frame_size;
820 * Return the frame duration in seconds. Return 0 if not available.
822 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
823 AVCodecParserContext *pc, AVPacket *pkt)
829 switch(st->codec->codec_type) {
830 case AVMEDIA_TYPE_VIDEO:
831 if (st->r_frame_rate.num) {
832 *pnum = st->r_frame_rate.den;
833 *pden = st->r_frame_rate.num;
834 } else if(st->time_base.num*1000LL > st->time_base.den) {
835 *pnum = st->time_base.num;
836 *pden = st->time_base.den;
837 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
838 *pnum = st->codec->time_base.num;
839 *pden = st->codec->time_base.den;
840 if (pc && pc->repeat_pict) {
841 *pnum = (*pnum) * (1 + pc->repeat_pict);
843 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
844 //Thus if we have no parser in such case leave duration undefined.
845 if(st->codec->ticks_per_frame>1 && !pc){
850 case AVMEDIA_TYPE_AUDIO:
851 frame_size = get_audio_frame_size(st->codec, pkt->size);
852 if (frame_size <= 0 || st->codec->sample_rate <= 0)
855 *pden = st->codec->sample_rate;
862 static int is_intra_only(AVCodecContext *enc){
863 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
865 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
866 switch(enc->codec_id){
868 case CODEC_ID_MJPEGB:
870 case CODEC_ID_PRORES:
871 case CODEC_ID_RAWVIDEO:
872 case CODEC_ID_DVVIDEO:
873 case CODEC_ID_HUFFYUV:
874 case CODEC_ID_FFVHUFF:
879 case CODEC_ID_JPEG2000:
887 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
888 int64_t dts, int64_t pts)
890 AVStream *st= s->streams[stream_index];
891 AVPacketList *pktl= s->packet_buffer;
893 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
896 st->first_dts= dts - st->cur_dts;
899 for(; pktl; pktl= pktl->next){
900 if(pktl->pkt.stream_index != stream_index)
902 //FIXME think more about this check
903 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
904 pktl->pkt.pts += st->first_dts;
906 if(pktl->pkt.dts != AV_NOPTS_VALUE)
907 pktl->pkt.dts += st->first_dts;
909 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
910 st->start_time= pktl->pkt.pts;
912 if (st->start_time == AV_NOPTS_VALUE)
913 st->start_time = pts;
916 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
918 AVPacketList *pktl= s->packet_buffer;
921 if(st->first_dts != AV_NOPTS_VALUE){
922 cur_dts= st->first_dts;
923 for(; pktl; pktl= pktl->next){
924 if(pktl->pkt.stream_index == pkt->stream_index){
925 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
927 cur_dts -= pkt->duration;
930 pktl= s->packet_buffer;
931 st->first_dts = cur_dts;
932 }else if(st->cur_dts)
935 for(; pktl; pktl= pktl->next){
936 if(pktl->pkt.stream_index != pkt->stream_index)
938 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
939 && !pktl->pkt.duration){
940 pktl->pkt.dts= cur_dts;
941 if(!st->codec->has_b_frames)
942 pktl->pkt.pts= cur_dts;
943 cur_dts += pkt->duration;
944 pktl->pkt.duration= pkt->duration;
948 if(st->first_dts == AV_NOPTS_VALUE)
949 st->cur_dts= cur_dts;
952 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
953 AVCodecParserContext *pc, AVPacket *pkt)
955 int num, den, presentation_delayed, delay, i;
958 if (s->flags & AVFMT_FLAG_NOFILLIN)
961 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
962 pkt->dts= AV_NOPTS_VALUE;
964 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
965 //FIXME Set low_delay = 0 when has_b_frames = 1
966 st->codec->has_b_frames = 1;
968 /* do we have a video B-frame ? */
969 delay= st->codec->has_b_frames;
970 presentation_delayed = 0;
972 /* XXX: need has_b_frame, but cannot get it if the codec is
975 pc && pc->pict_type != AV_PICTURE_TYPE_B)
976 presentation_delayed = 1;
978 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
979 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
980 pkt->dts -= 1LL<<st->pts_wrap_bits;
983 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
984 // we take the conservative approach and discard both
985 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
986 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
987 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
988 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
991 if (pkt->duration == 0) {
992 compute_frame_duration(&num, &den, st, pc, pkt);
994 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
996 if(pkt->duration != 0 && s->packet_buffer)
997 update_initial_durations(s, st, pkt);
1001 /* correct timestamps with byte offset if demuxers only have timestamps
1002 on packet boundaries */
1003 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1004 /* this will estimate bitrate based on this frame's duration and size */
1005 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1006 if(pkt->pts != AV_NOPTS_VALUE)
1008 if(pkt->dts != AV_NOPTS_VALUE)
1012 if (pc && pc->dts_sync_point >= 0) {
1013 // we have synchronization info from the parser
1014 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1016 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1017 if (pkt->dts != AV_NOPTS_VALUE) {
1018 // got DTS from the stream, update reference timestamp
1019 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1020 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1021 } else if (st->reference_dts != AV_NOPTS_VALUE) {
1022 // compute DTS based on reference timestamp
1023 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1024 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1026 if (pc->dts_sync_point > 0)
1027 st->reference_dts = pkt->dts; // new reference
1031 /* This may be redundant, but it should not hurt. */
1032 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1033 presentation_delayed = 1;
1035 // av_log(NULL, AV_LOG_DEBUG, "IN delayed:%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64" st:%d pc:%p\n", presentation_delayed, pkt->pts, pkt->dts, st->cur_dts, pkt->stream_index, pc);
1036 /* interpolate PTS and DTS if they are not present */
1037 //We skip H264 currently because delay and has_b_frames are not reliably set
1038 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1039 if (presentation_delayed) {
1040 /* DTS = decompression timestamp */
1041 /* PTS = presentation timestamp */
1042 if (pkt->dts == AV_NOPTS_VALUE)
1043 pkt->dts = st->last_IP_pts;
1044 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1045 if (pkt->dts == AV_NOPTS_VALUE)
1046 pkt->dts = st->cur_dts;
1048 /* this is tricky: the dts must be incremented by the duration
1049 of the frame we are displaying, i.e. the last I- or P-frame */
1050 if (st->last_IP_duration == 0)
1051 st->last_IP_duration = pkt->duration;
1052 if(pkt->dts != AV_NOPTS_VALUE)
1053 st->cur_dts = pkt->dts + st->last_IP_duration;
1054 st->last_IP_duration = pkt->duration;
1055 st->last_IP_pts= pkt->pts;
1056 /* cannot compute PTS if not present (we can compute it only
1057 by knowing the future */
1058 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1059 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1060 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1061 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1062 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1063 pkt->pts += pkt->duration;
1064 // av_log(NULL, AV_LOG_DEBUG, "id:%d old:%"PRId64" new:%"PRId64" dur:%d cur:%"PRId64" size:%d\n", pkt->stream_index, old_diff, new_diff, pkt->duration, st->cur_dts, pkt->size);
1068 /* presentation is not delayed : PTS and DTS are the same */
1069 if(pkt->pts == AV_NOPTS_VALUE)
1070 pkt->pts = pkt->dts;
1071 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1072 if(pkt->pts == AV_NOPTS_VALUE)
1073 pkt->pts = st->cur_dts;
1074 pkt->dts = pkt->pts;
1075 if(pkt->pts != AV_NOPTS_VALUE)
1076 st->cur_dts = pkt->pts + pkt->duration;
1080 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1081 st->pts_buffer[0]= pkt->pts;
1082 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1083 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1084 if(pkt->dts == AV_NOPTS_VALUE)
1085 pkt->dts= st->pts_buffer[0];
1086 if(st->codec->codec_id == CODEC_ID_H264){ // we skipped it above so we try here
1087 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1089 if(pkt->dts > st->cur_dts)
1090 st->cur_dts = pkt->dts;
1093 // av_log(NULL, AV_LOG_ERROR, "OUTdelayed:%d/%d pts:%"PRId64", dts:%"PRId64" cur_dts:%"PRId64"\n", presentation_delayed, delay, pkt->pts, pkt->dts, st->cur_dts);
1096 if(is_intra_only(st->codec))
1097 pkt->flags |= AV_PKT_FLAG_KEY;
1100 /* keyframe computation */
1101 if (pc->key_frame == 1)
1102 pkt->flags |= AV_PKT_FLAG_KEY;
1103 else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
1104 pkt->flags |= AV_PKT_FLAG_KEY;
1107 pkt->convergence_duration = pc->convergence_duration;
1111 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1116 av_init_packet(pkt);
1119 /* select current input stream component */
1122 if (!st->need_parsing || !st->parser) {
1123 /* no parsing needed: we just output the packet as is */
1124 /* raw data support */
1125 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1126 compute_pkt_fields(s, st, NULL, pkt);
1128 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1129 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1130 ff_reduce_index(s, st->index);
1131 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1134 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1135 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1136 st->cur_ptr, st->cur_len,
1137 st->cur_pkt.pts, st->cur_pkt.dts,
1139 st->cur_pkt.pts = AV_NOPTS_VALUE;
1140 st->cur_pkt.dts = AV_NOPTS_VALUE;
1141 /* increment read pointer */
1145 /* return packet if any */
1149 pkt->stream_index = st->index;
1150 pkt->pts = st->parser->pts;
1151 pkt->dts = st->parser->dts;
1152 pkt->pos = st->parser->pos;
1153 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1155 pkt->destruct= st->cur_pkt.destruct;
1156 st->cur_pkt.destruct= NULL;
1157 st->cur_pkt.data = NULL;
1158 assert(st->cur_len == 0);
1160 pkt->destruct = NULL;
1162 compute_pkt_fields(s, st, st->parser, pkt);
1164 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1165 ff_reduce_index(s, st->index);
1166 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1167 0, 0, AVINDEX_KEYFRAME);
1174 av_free_packet(&st->cur_pkt);
1179 /* read next packet */
1180 ret = av_read_packet(s, &cur_pkt);
1182 if (ret == AVERROR(EAGAIN))
1184 /* return the last frames, if any */
1185 for(i = 0; i < s->nb_streams; i++) {
1187 if (st->parser && st->need_parsing) {
1188 av_parser_parse2(st->parser, st->codec,
1189 &pkt->data, &pkt->size,
1191 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1197 /* no more packets: really terminate parsing */
1200 st = s->streams[cur_pkt.stream_index];
1201 st->cur_pkt= cur_pkt;
1203 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1204 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1205 st->cur_pkt.pts < st->cur_pkt.dts){
1206 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1207 st->cur_pkt.stream_index,
1211 // av_free_packet(&st->cur_pkt);
1215 if(s->debug & FF_FDEBUG_TS)
1216 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1217 st->cur_pkt.stream_index,
1221 st->cur_pkt.duration,
1225 st->cur_ptr = st->cur_pkt.data;
1226 st->cur_len = st->cur_pkt.size;
1227 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1228 st->parser = av_parser_init(st->codec->codec_id);
1230 /* no parser available: just output the raw packets */
1231 st->need_parsing = AVSTREAM_PARSE_NONE;
1232 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1233 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1234 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1235 st->parser->flags |= PARSER_FLAG_ONCE;
1240 if(s->debug & FF_FDEBUG_TS)
1241 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1252 static int read_from_packet_buffer(AVFormatContext *s, AVPacket *pkt)
1254 AVPacketList *pktl = s->packet_buffer;
1257 s->packet_buffer = pktl->next;
1262 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1264 const int genpts = s->flags & AVFMT_FLAG_GENPTS;
1268 return s->packet_buffer ? read_from_packet_buffer(s, pkt) :
1269 read_frame_internal(s, pkt);
1273 AVPacketList *pktl = s->packet_buffer;
1276 AVPacket *next_pkt = &pktl->pkt;
1278 if (next_pkt->dts != AV_NOPTS_VALUE) {
1279 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1280 while (pktl && next_pkt->pts == AV_NOPTS_VALUE) {
1281 if (pktl->pkt.stream_index == next_pkt->stream_index &&
1282 (av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)) < 0) &&
1283 av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1284 next_pkt->pts = pktl->pkt.dts;
1288 pktl = s->packet_buffer;
1291 /* read packet from packet buffer, if there is data */
1292 if (!(next_pkt->pts == AV_NOPTS_VALUE &&
1293 next_pkt->dts != AV_NOPTS_VALUE && !eof))
1294 return read_from_packet_buffer(s, pkt);
1297 ret = read_frame_internal(s, pkt);
1299 if (pktl && ret != AVERROR(EAGAIN)) {
1306 if (av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1307 &s->packet_buffer_end)) < 0)
1308 return AVERROR(ENOMEM);
1312 /* XXX: suppress the packet queue */
1313 static void flush_packet_queue(AVFormatContext *s)
1318 pktl = s->packet_buffer;
1321 s->packet_buffer = pktl->next;
1322 av_free_packet(&pktl->pkt);
1325 while(s->raw_packet_buffer){
1326 pktl = s->raw_packet_buffer;
1327 s->raw_packet_buffer = pktl->next;
1328 av_free_packet(&pktl->pkt);
1331 s->packet_buffer_end=
1332 s->raw_packet_buffer_end= NULL;
1333 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1336 /*******************************************************/
1339 int av_find_default_stream_index(AVFormatContext *s)
1341 int first_audio_index = -1;
1345 if (s->nb_streams <= 0)
1347 for(i = 0; i < s->nb_streams; i++) {
1349 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1352 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1353 first_audio_index = i;
1355 return first_audio_index >= 0 ? first_audio_index : 0;
1359 * Flush the frame reader.
1361 void ff_read_frame_flush(AVFormatContext *s)
1366 flush_packet_queue(s);
1370 /* for each stream, reset read state */
1371 for(i = 0; i < s->nb_streams; i++) {
1375 av_parser_close(st->parser);
1377 av_free_packet(&st->cur_pkt);
1379 st->last_IP_pts = AV_NOPTS_VALUE;
1380 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1381 st->reference_dts = AV_NOPTS_VALUE;
1386 st->probe_packets = MAX_PROBE_PACKETS;
1388 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1389 st->pts_buffer[j]= AV_NOPTS_VALUE;
1393 #if FF_API_SEEK_PUBLIC
1394 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1396 ff_update_cur_dts(s, ref_st, timestamp);
1400 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1404 for(i = 0; i < s->nb_streams; i++) {
1405 AVStream *st = s->streams[i];
1407 st->cur_dts = av_rescale(timestamp,
1408 st->time_base.den * (int64_t)ref_st->time_base.num,
1409 st->time_base.num * (int64_t)ref_st->time_base.den);
1413 void ff_reduce_index(AVFormatContext *s, int stream_index)
1415 AVStream *st= s->streams[stream_index];
1416 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1418 if((unsigned)st->nb_index_entries >= max_entries){
1420 for(i=0; 2*i<st->nb_index_entries; i++)
1421 st->index_entries[i]= st->index_entries[2*i];
1422 st->nb_index_entries= i;
1426 int ff_add_index_entry(AVIndexEntry **index_entries,
1427 int *nb_index_entries,
1428 unsigned int *index_entries_allocated_size,
1429 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1431 AVIndexEntry *entries, *ie;
1434 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1437 entries = av_fast_realloc(*index_entries,
1438 index_entries_allocated_size,
1439 (*nb_index_entries + 1) *
1440 sizeof(AVIndexEntry));
1444 *index_entries= entries;
1446 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1449 index= (*nb_index_entries)++;
1450 ie= &entries[index];
1451 assert(index==0 || ie[-1].timestamp < timestamp);
1453 ie= &entries[index];
1454 if(ie->timestamp != timestamp){
1455 if(ie->timestamp <= timestamp)
1457 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1458 (*nb_index_entries)++;
1459 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1460 distance= ie->min_distance;
1464 ie->timestamp = timestamp;
1465 ie->min_distance= distance;
1472 int av_add_index_entry(AVStream *st,
1473 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1475 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1476 &st->index_entries_allocated_size, pos,
1477 timestamp, size, distance, flags);
1480 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1481 int64_t wanted_timestamp, int flags)
1489 //optimize appending index entries at the end
1490 if(b && entries[b-1].timestamp < wanted_timestamp)
1495 timestamp = entries[m].timestamp;
1496 if(timestamp >= wanted_timestamp)
1498 if(timestamp <= wanted_timestamp)
1501 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1503 if(!(flags & AVSEEK_FLAG_ANY)){
1504 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1505 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1514 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1517 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1518 wanted_timestamp, flags);
1521 #if FF_API_SEEK_PUBLIC
1522 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1523 return ff_seek_frame_binary(s, stream_index, target_ts, flags);
1527 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1529 AVInputFormat *avif= s->iformat;
1530 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1531 int64_t ts_min, ts_max, ts;
1536 if (stream_index < 0)
1539 av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1542 ts_min= AV_NOPTS_VALUE;
1543 pos_limit= -1; //gcc falsely says it may be uninitialized
1545 st= s->streams[stream_index];
1546 if(st->index_entries){
1549 index= av_index_search_timestamp(st, target_ts, flags | AVSEEK_FLAG_BACKWARD); //FIXME whole func must be checked for non-keyframe entries in index case, especially read_timestamp()
1550 index= FFMAX(index, 0);
1551 e= &st->index_entries[index];
1553 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1555 ts_min= e->timestamp;
1556 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1562 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1563 assert(index < st->nb_index_entries);
1565 e= &st->index_entries[index];
1566 assert(e->timestamp >= target_ts);
1568 ts_max= e->timestamp;
1569 pos_limit= pos_max - e->min_distance;
1570 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1571 pos_max,pos_limit, ts_max);
1575 pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1580 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1583 ff_update_cur_dts(s, st, ts);
1588 #if FF_API_SEEK_PUBLIC
1589 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1590 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1591 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1592 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1594 return ff_gen_search(s, stream_index, target_ts, pos_min, pos_max,
1595 pos_limit, ts_min, ts_max, flags, ts_ret,
1600 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1601 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1602 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1603 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1606 int64_t start_pos, filesize;
1609 av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1611 if(ts_min == AV_NOPTS_VALUE){
1612 pos_min = s->data_offset;
1613 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1614 if (ts_min == AV_NOPTS_VALUE)
1618 if(ts_max == AV_NOPTS_VALUE){
1620 filesize = avio_size(s->pb);
1621 pos_max = filesize - 1;
1624 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1626 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1627 if (ts_max == AV_NOPTS_VALUE)
1631 int64_t tmp_pos= pos_max + 1;
1632 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1633 if(tmp_ts == AV_NOPTS_VALUE)
1637 if(tmp_pos >= filesize)
1643 if(ts_min > ts_max){
1645 }else if(ts_min == ts_max){
1650 while (pos_min < pos_limit) {
1651 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1652 pos_min, pos_max, ts_min, ts_max);
1653 assert(pos_limit <= pos_max);
1656 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1657 // interpolate position (better than dichotomy)
1658 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1659 + pos_min - approximate_keyframe_distance;
1660 }else if(no_change==1){
1661 // bisection, if interpolation failed to change min or max pos last time
1662 pos = (pos_min + pos_limit)>>1;
1664 /* linear search if bisection failed, can only happen if there
1665 are very few or no keyframes between min/max */
1670 else if(pos > pos_limit)
1674 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1679 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1680 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1681 pos_limit, start_pos, no_change);
1682 if(ts == AV_NOPTS_VALUE){
1683 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1686 assert(ts != AV_NOPTS_VALUE);
1687 if (target_ts <= ts) {
1688 pos_limit = start_pos - 1;
1692 if (target_ts >= ts) {
1698 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1699 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1701 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1703 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1704 av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1705 pos, ts_min, target_ts, ts_max);
1710 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1711 int64_t pos_min, pos_max;
1715 if (stream_index < 0)
1718 st= s->streams[stream_index];
1721 pos_min = s->data_offset;
1722 pos_max = avio_size(s->pb) - 1;
1724 if (pos < pos_min) pos= pos_min;
1725 else if(pos > pos_max) pos= pos_max;
1727 avio_seek(s->pb, pos, SEEK_SET);
1730 av_update_cur_dts(s, st, ts);
1735 static int seek_frame_generic(AVFormatContext *s,
1736 int stream_index, int64_t timestamp, int flags)
1743 st = s->streams[stream_index];
1745 index = av_index_search_timestamp(st, timestamp, flags);
1747 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1750 if(index < 0 || index==st->nb_index_entries-1){
1753 if(st->nb_index_entries){
1754 assert(st->index_entries);
1755 ie= &st->index_entries[st->nb_index_entries-1];
1756 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1758 ff_update_cur_dts(s, st, ie->timestamp);
1760 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1766 read_status = av_read_frame(s, &pkt);
1767 } while (read_status == AVERROR(EAGAIN));
1768 if (read_status < 0)
1770 av_free_packet(&pkt);
1771 if(stream_index == pkt.stream_index){
1772 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1776 index = av_index_search_timestamp(st, timestamp, flags);
1781 ff_read_frame_flush(s);
1782 if (s->iformat->read_seek){
1783 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1786 ie = &st->index_entries[index];
1787 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1789 ff_update_cur_dts(s, st, ie->timestamp);
1794 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1799 if (flags & AVSEEK_FLAG_BYTE) {
1800 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1802 ff_read_frame_flush(s);
1803 return seek_frame_byte(s, stream_index, timestamp, flags);
1806 if(stream_index < 0){
1807 stream_index= av_find_default_stream_index(s);
1808 if(stream_index < 0)
1811 st= s->streams[stream_index];
1812 /* timestamp for default must be expressed in AV_TIME_BASE units */
1813 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1816 /* first, we try the format specific seek */
1817 if (s->iformat->read_seek) {
1818 ff_read_frame_flush(s);
1819 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1826 if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1827 ff_read_frame_flush(s);
1828 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1829 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1830 ff_read_frame_flush(s);
1831 return seek_frame_generic(s, stream_index, timestamp, flags);
1837 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1839 if(min_ts > ts || max_ts < ts)
1842 if (s->iformat->read_seek2) {
1843 ff_read_frame_flush(s);
1844 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1847 if(s->iformat->read_timestamp){
1848 //try to seek via read_timestamp()
1851 //Fallback to old API if new is not implemented but old is
1852 //Note the old has somewat different sematics
1853 if(s->iformat->read_seek || 1)
1854 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1856 // try some generic seek like seek_frame_generic() but with new ts semantics
1859 /*******************************************************/
1862 * Return TRUE if the stream has accurate duration in any stream.
1864 * @return TRUE if the stream has accurate duration for at least one component.
1866 static int has_duration(AVFormatContext *ic)
1871 for(i = 0;i < ic->nb_streams; i++) {
1872 st = ic->streams[i];
1873 if (st->duration != AV_NOPTS_VALUE)
1880 * Estimate the stream timings from the one of each components.
1882 * Also computes the global bitrate if possible.
1884 static void update_stream_timings(AVFormatContext *ic)
1886 int64_t start_time, start_time1, end_time, end_time1;
1887 int64_t duration, duration1, filesize;
1891 start_time = INT64_MAX;
1892 end_time = INT64_MIN;
1893 duration = INT64_MIN;
1894 for(i = 0;i < ic->nb_streams; i++) {
1895 st = ic->streams[i];
1896 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1897 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1898 start_time = FFMIN(start_time, start_time1);
1899 if (st->duration != AV_NOPTS_VALUE) {
1900 end_time1 = start_time1
1901 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1902 end_time = FFMAX(end_time, end_time1);
1905 if (st->duration != AV_NOPTS_VALUE) {
1906 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1907 duration = FFMAX(duration, duration1);
1910 if (start_time != INT64_MAX) {
1911 ic->start_time = start_time;
1912 if (end_time != INT64_MIN)
1913 duration = FFMAX(duration, end_time - start_time);
1915 if (duration != INT64_MIN) {
1916 ic->duration = duration;
1917 if (ic->pb && (filesize = avio_size(ic->pb)) > 0) {
1918 /* compute the bitrate */
1919 ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
1920 (double)ic->duration;
1925 static void fill_all_stream_timings(AVFormatContext *ic)
1930 update_stream_timings(ic);
1931 for(i = 0;i < ic->nb_streams; i++) {
1932 st = ic->streams[i];
1933 if (st->start_time == AV_NOPTS_VALUE) {
1934 if(ic->start_time != AV_NOPTS_VALUE)
1935 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1936 if(ic->duration != AV_NOPTS_VALUE)
1937 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1942 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1944 int64_t filesize, duration;
1948 /* if bit_rate is already set, we believe it */
1949 if (ic->bit_rate <= 0) {
1951 for(i=0;i<ic->nb_streams;i++) {
1952 st = ic->streams[i];
1953 if (st->codec->bit_rate > 0)
1954 bit_rate += st->codec->bit_rate;
1956 ic->bit_rate = bit_rate;
1959 /* if duration is already set, we believe it */
1960 if (ic->duration == AV_NOPTS_VALUE &&
1961 ic->bit_rate != 0) {
1962 filesize = ic->pb ? avio_size(ic->pb) : 0;
1964 for(i = 0; i < ic->nb_streams; i++) {
1965 st = ic->streams[i];
1966 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1967 if (st->duration == AV_NOPTS_VALUE)
1968 st->duration = duration;
1974 #define DURATION_MAX_READ_SIZE 250000
1975 #define DURATION_MAX_RETRY 3
1977 /* only usable for MPEG-PS streams */
1978 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1980 AVPacket pkt1, *pkt = &pkt1;
1982 int read_size, i, ret;
1984 int64_t filesize, offset, duration;
1989 /* flush packet queue */
1990 flush_packet_queue(ic);
1992 for (i=0; i<ic->nb_streams; i++) {
1993 st = ic->streams[i];
1994 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1995 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
1998 av_parser_close(st->parser);
2000 av_free_packet(&st->cur_pkt);
2004 /* estimate the end time (duration) */
2005 /* XXX: may need to support wrapping */
2006 filesize = ic->pb ? avio_size(ic->pb) : 0;
2007 end_time = AV_NOPTS_VALUE;
2009 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2013 avio_seek(ic->pb, offset, SEEK_SET);
2016 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2020 ret = av_read_packet(ic, pkt);
2021 } while(ret == AVERROR(EAGAIN));
2024 read_size += pkt->size;
2025 st = ic->streams[pkt->stream_index];
2026 if (pkt->pts != AV_NOPTS_VALUE &&
2027 (st->start_time != AV_NOPTS_VALUE ||
2028 st->first_dts != AV_NOPTS_VALUE)) {
2029 duration = end_time = pkt->pts;
2030 if (st->start_time != AV_NOPTS_VALUE)
2031 duration -= st->start_time;
2033 duration -= st->first_dts;
2035 duration += 1LL<<st->pts_wrap_bits;
2037 if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
2038 st->duration = duration;
2041 av_free_packet(pkt);
2043 }while( end_time==AV_NOPTS_VALUE
2044 && filesize > (DURATION_MAX_READ_SIZE<<retry)
2045 && ++retry <= DURATION_MAX_RETRY);
2047 fill_all_stream_timings(ic);
2049 avio_seek(ic->pb, old_offset, SEEK_SET);
2050 for (i=0; i<ic->nb_streams; i++) {
2052 st->cur_dts= st->first_dts;
2053 st->last_IP_pts = AV_NOPTS_VALUE;
2054 st->reference_dts = AV_NOPTS_VALUE;
2058 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2062 /* get the file size, if possible */
2063 if (ic->iformat->flags & AVFMT_NOFILE) {
2066 file_size = avio_size(ic->pb);
2067 file_size = FFMAX(0, file_size);
2070 if ((!strcmp(ic->iformat->name, "mpeg") ||
2071 !strcmp(ic->iformat->name, "mpegts")) &&
2072 file_size && ic->pb->seekable) {
2073 /* get accurate estimate from the PTSes */
2074 estimate_timings_from_pts(ic, old_offset);
2075 } else if (has_duration(ic)) {
2076 /* at least one component has timings - we use them for all
2078 fill_all_stream_timings(ic);
2080 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2081 /* less precise: use bitrate info */
2082 estimate_timings_from_bit_rate(ic);
2084 update_stream_timings(ic);
2088 AVStream av_unused *st;
2089 for(i = 0;i < ic->nb_streams; i++) {
2090 st = ic->streams[i];
2091 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2092 (double) st->start_time / AV_TIME_BASE,
2093 (double) st->duration / AV_TIME_BASE);
2095 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2096 (double) ic->start_time / AV_TIME_BASE,
2097 (double) ic->duration / AV_TIME_BASE,
2098 ic->bit_rate / 1000);
2102 static int has_codec_parameters(AVCodecContext *avctx)
2105 switch (avctx->codec_type) {
2106 case AVMEDIA_TYPE_AUDIO:
2107 val = avctx->sample_rate && avctx->channels && avctx->sample_fmt != AV_SAMPLE_FMT_NONE;
2108 if (!avctx->frame_size &&
2109 (avctx->codec_id == CODEC_ID_VORBIS ||
2110 avctx->codec_id == CODEC_ID_AAC ||
2111 avctx->codec_id == CODEC_ID_MP1 ||
2112 avctx->codec_id == CODEC_ID_MP2 ||
2113 avctx->codec_id == CODEC_ID_MP3 ||
2114 avctx->codec_id == CODEC_ID_CELT))
2117 case AVMEDIA_TYPE_VIDEO:
2118 val = avctx->width && avctx->pix_fmt != PIX_FMT_NONE;
2124 return avctx->codec_id != CODEC_ID_NONE && val != 0;
2127 static int has_decode_delay_been_guessed(AVStream *st)
2129 return st->codec->codec_id != CODEC_ID_H264 ||
2130 st->info->nb_decoded_frames >= 6;
2133 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2136 int got_picture = 1, ret = 0;
2138 AVPacket pkt = *avpkt;
2140 if(!st->codec->codec){
2141 AVDictionary *thread_opt = NULL;
2143 codec = avcodec_find_decoder(st->codec->codec_id);
2147 /* force thread count to 1 since the h264 decoder will not extract SPS
2148 * and PPS to extradata during multi-threaded decoding */
2149 av_dict_set(options ? options : &thread_opt, "threads", "1", 0);
2150 ret = avcodec_open2(st->codec, codec, options ? options : &thread_opt);
2152 av_dict_free(&thread_opt);
2157 while ((pkt.size > 0 || (!pkt.data && got_picture)) &&
2159 (!has_codec_parameters(st->codec) ||
2160 !has_decode_delay_been_guessed(st) ||
2161 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF))) {
2163 avcodec_get_frame_defaults(&picture);
2164 switch(st->codec->codec_type) {
2165 case AVMEDIA_TYPE_VIDEO:
2166 ret = avcodec_decode_video2(st->codec, &picture,
2167 &got_picture, &pkt);
2169 case AVMEDIA_TYPE_AUDIO:
2170 ret = avcodec_decode_audio4(st->codec, &picture, &got_picture, &pkt);
2177 st->info->nb_decoded_frames++;
2185 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2187 while (tags->id != CODEC_ID_NONE) {
2195 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2198 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2199 if(tag == tags[i].tag)
2202 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2203 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2206 return CODEC_ID_NONE;
2209 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2212 for(i=0; tags && tags[i]; i++){
2213 int tag= ff_codec_get_tag(tags[i], id);
2219 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2222 for(i=0; tags && tags[i]; i++){
2223 enum CodecID id= ff_codec_get_id(tags[i], tag);
2224 if(id!=CODEC_ID_NONE) return id;
2226 return CODEC_ID_NONE;
2229 static void compute_chapters_end(AVFormatContext *s)
2232 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2234 for (i = 0; i < s->nb_chapters; i++)
2235 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2236 AVChapter *ch = s->chapters[i];
2237 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2240 for (j = 0; j < s->nb_chapters; j++) {
2241 AVChapter *ch1 = s->chapters[j];
2242 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2243 if (j != i && next_start > ch->start && next_start < end)
2246 ch->end = (end == INT64_MAX) ? ch->start : end;
2250 static int get_std_framerate(int i){
2251 if(i<60*12) return i*1001;
2252 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2256 * Is the time base unreliable.
2257 * This is a heuristic to balance between quick acceptance of the values in
2258 * the headers vs. some extra checks.
2259 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2260 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2261 * And there are "variable" fps files this needs to detect as well.
2263 static int tb_unreliable(AVCodecContext *c){
2264 if( c->time_base.den >= 101L*c->time_base.num
2265 || c->time_base.den < 5L*c->time_base.num
2266 /* || c->codec_tag == AV_RL32("DIVX")
2267 || c->codec_tag == AV_RL32("XVID")*/
2268 || c->codec_id == CODEC_ID_MPEG2VIDEO
2269 || c->codec_id == CODEC_ID_H264
2275 #if FF_API_FORMAT_PARAMETERS
2276 int av_find_stream_info(AVFormatContext *ic)
2278 return avformat_find_stream_info(ic, NULL);
2282 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2284 int i, count, ret, read_size, j;
2286 AVPacket pkt1, *pkt;
2287 int64_t old_offset = avio_tell(ic->pb);
2288 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2290 for(i=0;i<ic->nb_streams;i++) {
2292 AVDictionary *thread_opt = NULL;
2293 st = ic->streams[i];
2295 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2296 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2297 /* if(!st->time_base.num)
2299 if(!st->codec->time_base.num)
2300 st->codec->time_base= st->time_base;
2302 //only for the split stuff
2303 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2304 st->parser = av_parser_init(st->codec->codec_id);
2305 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2306 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2309 assert(!st->codec->codec);
2310 codec = avcodec_find_decoder(st->codec->codec_id);
2312 /* force thread count to 1 since the h264 decoder will not extract SPS
2313 * and PPS to extradata during multi-threaded decoding */
2314 av_dict_set(options ? &options[i] : &thread_opt, "threads", "1", 0);
2316 /* Ensure that subtitle_header is properly set. */
2317 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2318 && codec && !st->codec->codec)
2319 avcodec_open2(st->codec, codec, options ? &options[i]
2322 //try to just open decoders, in case this is enough to get parameters
2323 if(!has_codec_parameters(st->codec)){
2324 if (codec && !st->codec->codec)
2325 avcodec_open2(st->codec, codec, options ? &options[i]
2329 av_dict_free(&thread_opt);
2332 for (i=0; i<ic->nb_streams; i++) {
2333 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2339 if (ff_check_interrupt(&ic->interrupt_callback)){
2341 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2345 /* check if one codec still needs to be handled */
2346 for(i=0;i<ic->nb_streams;i++) {
2347 int fps_analyze_framecount = 20;
2349 st = ic->streams[i];
2350 if (!has_codec_parameters(st->codec))
2352 /* if the timebase is coarse (like the usual millisecond precision
2353 of mkv), we need to analyze more frames to reliably arrive at
2355 if (av_q2d(st->time_base) > 0.0005)
2356 fps_analyze_framecount *= 2;
2357 if (ic->fps_probe_size >= 0)
2358 fps_analyze_framecount = ic->fps_probe_size;
2359 /* variable fps and no guess at the real fps */
2360 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2361 && st->info->duration_count < fps_analyze_framecount
2362 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2364 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2366 if(st->first_dts == AV_NOPTS_VALUE)
2369 if (i == ic->nb_streams) {
2370 /* NOTE: if the format has no header, then we need to read
2371 some packets to get most of the streams, so we cannot
2373 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2374 /* if we found the info for all the codecs, we can stop */
2376 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2380 /* we did not get all the codec info, but we read too much data */
2381 if (read_size >= ic->probesize) {
2383 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2387 /* NOTE: a new stream can be added there if no header in file
2388 (AVFMTCTX_NOHEADER) */
2389 ret = read_frame_internal(ic, &pkt1);
2390 if (ret == AVERROR(EAGAIN))
2395 AVPacket empty_pkt = { 0 };
2397 av_init_packet(&empty_pkt);
2399 ret = -1; /* we could not have all the codec parameters before EOF */
2400 for(i=0;i<ic->nb_streams;i++) {
2401 st = ic->streams[i];
2403 /* flush the decoders */
2404 while ((err = try_decode_frame(st, &empty_pkt,
2405 (options && i < orig_nb_streams) ?
2406 &options[i] : NULL)) >= 0)
2407 if (has_codec_parameters(st->codec))
2410 if (!has_codec_parameters(st->codec)){
2412 avcodec_string(buf, sizeof(buf), st->codec, 0);
2413 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2421 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2422 if ((ret = av_dup_packet(pkt)) < 0)
2423 goto find_stream_info_err;
2425 read_size += pkt->size;
2427 st = ic->streams[pkt->stream_index];
2428 if (st->codec_info_nb_frames>1) {
2429 if (st->time_base.den > 0 && av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2430 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2433 st->info->codec_info_duration += pkt->duration;
2436 int64_t last = st->info->last_dts;
2438 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
2439 int64_t duration= pkt->dts - last;
2440 double dur= duration * av_q2d(st->time_base);
2442 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2443 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2444 if (st->info->duration_count < 2)
2445 memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2446 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2447 int framerate= get_std_framerate(i);
2448 int ticks= lrintf(dur*framerate/(1001*12));
2449 double error = dur - (double)ticks*1001*12 / framerate;
2450 st->info->duration_error[i] += error*error;
2452 st->info->duration_count++;
2453 // ignore the first 4 values, they might have some random jitter
2454 if (st->info->duration_count > 3)
2455 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2457 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2458 st->info->last_dts = pkt->dts;
2460 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2461 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2462 if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
2463 st->codec->extradata_size= i;
2464 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2465 if (!st->codec->extradata)
2466 return AVERROR(ENOMEM);
2467 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2468 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2472 /* if still no information, we try to open the codec and to
2473 decompress the frame. We try to avoid that in most cases as
2474 it takes longer and uses more memory. For MPEG-4, we need to
2475 decompress for QuickTime.
2477 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2478 least one frame of codec data, this makes sure the codec initializes
2479 the channel configuration and does not only trust the values from the container.
2481 try_decode_frame(st, pkt, (options && i < orig_nb_streams ) ? &options[i] : NULL);
2483 st->codec_info_nb_frames++;
2487 // close codecs which were opened in try_decode_frame()
2488 for(i=0;i<ic->nb_streams;i++) {
2489 st = ic->streams[i];
2490 if(st->codec->codec)
2491 avcodec_close(st->codec);
2493 for(i=0;i<ic->nb_streams;i++) {
2494 st = ic->streams[i];
2495 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2496 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2497 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2498 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2499 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2500 // the check for tb_unreliable() is not completely correct, since this is not about handling
2501 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2502 // ipmovie.c produces.
2503 if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2504 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
2505 if (st->info->duration_count && !st->r_frame_rate.num
2506 && tb_unreliable(st->codec) /*&&
2507 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2508 st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2510 double best_error= 2*av_q2d(st->time_base);
2511 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2513 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2514 double error = st->info->duration_error[j] * get_std_framerate(j);
2515 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2516 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2517 if(error < best_error){
2519 num = get_std_framerate(j);
2522 // do not increase frame rate by more than 1 % in order to match a standard rate.
2523 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2524 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2527 if (!st->r_frame_rate.num){
2528 if( st->codec->time_base.den * (int64_t)st->time_base.num
2529 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2530 st->r_frame_rate.num = st->codec->time_base.den;
2531 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2533 st->r_frame_rate.num = st->time_base.den;
2534 st->r_frame_rate.den = st->time_base.num;
2537 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2538 if(!st->codec->bits_per_coded_sample)
2539 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2540 // set stream disposition based on audio service type
2541 switch (st->codec->audio_service_type) {
2542 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2543 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2544 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2545 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2546 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2547 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2548 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2549 st->disposition = AV_DISPOSITION_COMMENT; break;
2550 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2551 st->disposition = AV_DISPOSITION_KARAOKE; break;
2556 estimate_timings(ic, old_offset);
2558 compute_chapters_end(ic);
2561 /* correct DTS for B-frame streams with no timestamps */
2562 for(i=0;i<ic->nb_streams;i++) {
2563 st = ic->streams[i];
2564 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2566 ppktl = &ic->packet_buffer;
2568 if(ppkt1->stream_index != i)
2570 if(ppkt1->pkt->dts < 0)
2572 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2574 ppkt1->pkt->dts -= delta;
2579 st->cur_dts -= delta;
2585 find_stream_info_err:
2586 for (i=0; i < ic->nb_streams; i++) {
2587 if (ic->streams[i]->codec)
2588 ic->streams[i]->codec->thread_count = 0;
2589 av_freep(&ic->streams[i]->info);
2594 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2598 for (i = 0; i < ic->nb_programs; i++)
2599 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2600 if (ic->programs[i]->stream_index[j] == s)
2601 return ic->programs[i];
2605 int av_find_best_stream(AVFormatContext *ic,
2606 enum AVMediaType type,
2607 int wanted_stream_nb,
2609 AVCodec **decoder_ret,
2612 int i, nb_streams = ic->nb_streams;
2613 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2614 unsigned *program = NULL;
2615 AVCodec *decoder = NULL, *best_decoder = NULL;
2617 if (related_stream >= 0 && wanted_stream_nb < 0) {
2618 AVProgram *p = find_program_from_stream(ic, related_stream);
2620 program = p->stream_index;
2621 nb_streams = p->nb_stream_indexes;
2624 for (i = 0; i < nb_streams; i++) {
2625 int real_stream_index = program ? program[i] : i;
2626 AVStream *st = ic->streams[real_stream_index];
2627 AVCodecContext *avctx = st->codec;
2628 if (avctx->codec_type != type)
2630 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2632 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2635 decoder = avcodec_find_decoder(st->codec->codec_id);
2638 ret = AVERROR_DECODER_NOT_FOUND;
2642 if (best_count >= st->codec_info_nb_frames)
2644 best_count = st->codec_info_nb_frames;
2645 ret = real_stream_index;
2646 best_decoder = decoder;
2647 if (program && i == nb_streams - 1 && ret < 0) {
2649 nb_streams = ic->nb_streams;
2650 i = 0; /* no related stream found, try again with everything */
2654 *decoder_ret = best_decoder;
2658 /*******************************************************/
2660 int av_read_play(AVFormatContext *s)
2662 if (s->iformat->read_play)
2663 return s->iformat->read_play(s);
2665 return avio_pause(s->pb, 0);
2666 return AVERROR(ENOSYS);
2669 int av_read_pause(AVFormatContext *s)
2671 if (s->iformat->read_pause)
2672 return s->iformat->read_pause(s);
2674 return avio_pause(s->pb, 1);
2675 return AVERROR(ENOSYS);
2678 #if FF_API_FORMAT_PARAMETERS
2679 void av_close_input_stream(AVFormatContext *s)
2681 flush_packet_queue(s);
2682 if (s->iformat->read_close)
2683 s->iformat->read_close(s);
2684 avformat_free_context(s);
2688 void avformat_free_context(AVFormatContext *s)
2694 if (s->iformat && s->iformat->priv_class && s->priv_data)
2695 av_opt_free(s->priv_data);
2697 for(i=0;i<s->nb_streams;i++) {
2698 /* free all data in a stream component */
2701 av_parser_close(st->parser);
2702 av_free_packet(&st->cur_pkt);
2704 av_dict_free(&st->metadata);
2705 av_free(st->index_entries);
2706 av_free(st->codec->extradata);
2707 av_free(st->codec->subtitle_header);
2709 av_free(st->priv_data);
2713 for(i=s->nb_programs-1; i>=0; i--) {
2714 av_dict_free(&s->programs[i]->metadata);
2715 av_freep(&s->programs[i]->stream_index);
2716 av_freep(&s->programs[i]);
2718 av_freep(&s->programs);
2719 av_freep(&s->priv_data);
2720 while(s->nb_chapters--) {
2721 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2722 av_free(s->chapters[s->nb_chapters]);
2724 av_freep(&s->chapters);
2725 av_dict_free(&s->metadata);
2726 av_freep(&s->streams);
2730 #if FF_API_CLOSE_INPUT_FILE
2731 void av_close_input_file(AVFormatContext *s)
2733 avformat_close_input(&s);
2737 void avformat_close_input(AVFormatContext **ps)
2739 AVFormatContext *s = *ps;
2740 AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2742 flush_packet_queue(s);
2743 if (s->iformat->read_close)
2744 s->iformat->read_close(s);
2745 avformat_free_context(s);
2751 #if FF_API_NEW_STREAM
2752 AVStream *av_new_stream(AVFormatContext *s, int id)
2754 AVStream *st = avformat_new_stream(s, NULL);
2761 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2767 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2769 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2772 s->streams = streams;
2774 st = av_mallocz(sizeof(AVStream));
2777 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2782 st->codec = avcodec_alloc_context3(c);
2784 /* no default bitrate if decoding */
2785 st->codec->bit_rate = 0;
2787 st->index = s->nb_streams;
2788 st->start_time = AV_NOPTS_VALUE;
2789 st->duration = AV_NOPTS_VALUE;
2790 /* we set the current DTS to 0 so that formats without any timestamps
2791 but durations get some timestamps, formats with some unknown
2792 timestamps have their first few packets buffered and the
2793 timestamps corrected before they are returned to the user */
2795 st->first_dts = AV_NOPTS_VALUE;
2796 st->probe_packets = MAX_PROBE_PACKETS;
2798 /* default pts setting is MPEG-like */
2799 avpriv_set_pts_info(st, 33, 1, 90000);
2800 st->last_IP_pts = AV_NOPTS_VALUE;
2801 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2802 st->pts_buffer[i]= AV_NOPTS_VALUE;
2803 st->reference_dts = AV_NOPTS_VALUE;
2805 st->sample_aspect_ratio = (AVRational){0,1};
2807 s->streams[s->nb_streams++] = st;
2811 AVProgram *av_new_program(AVFormatContext *ac, int id)
2813 AVProgram *program=NULL;
2816 av_dlog(ac, "new_program: id=0x%04x\n", id);
2818 for(i=0; i<ac->nb_programs; i++)
2819 if(ac->programs[i]->id == id)
2820 program = ac->programs[i];
2823 program = av_mallocz(sizeof(AVProgram));
2826 dynarray_add(&ac->programs, &ac->nb_programs, program);
2827 program->discard = AVDISCARD_NONE;
2834 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2836 AVChapter *chapter = NULL;
2839 for(i=0; i<s->nb_chapters; i++)
2840 if(s->chapters[i]->id == id)
2841 chapter = s->chapters[i];
2844 chapter= av_mallocz(sizeof(AVChapter));
2847 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2849 av_dict_set(&chapter->metadata, "title", title, 0);
2851 chapter->time_base= time_base;
2852 chapter->start = start;
2858 /************************************************************/
2859 /* output media file */
2861 #if FF_API_FORMAT_PARAMETERS
2862 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2866 if (s->oformat->priv_data_size > 0) {
2867 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2869 return AVERROR(ENOMEM);
2870 if (s->oformat->priv_class) {
2871 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2872 av_opt_set_defaults(s->priv_data);
2875 s->priv_data = NULL;
2877 if (s->oformat->set_parameters) {
2878 ret = s->oformat->set_parameters(s, ap);
2886 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2888 const AVCodecTag *avctag;
2890 enum CodecID id = CODEC_ID_NONE;
2891 unsigned int tag = 0;
2894 * Check that tag + id is in the table
2895 * If neither is in the table -> OK
2896 * If tag is in the table with another id -> FAIL
2897 * If id is in the table with another tag -> FAIL unless strict < normal
2899 for (n = 0; s->oformat->codec_tag[n]; n++) {
2900 avctag = s->oformat->codec_tag[n];
2901 while (avctag->id != CODEC_ID_NONE) {
2902 if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
2904 if (id == st->codec->codec_id)
2907 if (avctag->id == st->codec->codec_id)
2912 if (id != CODEC_ID_NONE)
2914 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2919 #if FF_API_FORMAT_PARAMETERS
2920 int av_write_header(AVFormatContext *s)
2922 return avformat_write_header(s, NULL);
2926 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2930 AVDictionary *tmp = NULL;
2933 av_dict_copy(&tmp, *options, 0);
2934 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2937 // some sanity checks
2938 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2939 av_log(s, AV_LOG_ERROR, "no streams\n");
2940 ret = AVERROR(EINVAL);
2944 for(i=0;i<s->nb_streams;i++) {
2947 switch (st->codec->codec_type) {
2948 case AVMEDIA_TYPE_AUDIO:
2949 if(st->codec->sample_rate<=0){
2950 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2951 ret = AVERROR(EINVAL);
2954 if(!st->codec->block_align)
2955 st->codec->block_align = st->codec->channels *
2956 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2958 case AVMEDIA_TYPE_VIDEO:
2959 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2960 av_log(s, AV_LOG_ERROR, "time base not set\n");
2961 ret = AVERROR(EINVAL);
2964 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2965 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2966 ret = AVERROR(EINVAL);
2969 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2970 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2971 ret = AVERROR(EINVAL);
2977 if(s->oformat->codec_tag){
2978 if(st->codec->codec_tag && st->codec->codec_id == CODEC_ID_RAWVIDEO && av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id) == 0 && !validate_codec_tag(s, st)){
2979 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2980 st->codec->codec_tag= 0;
2982 if(st->codec->codec_tag){
2983 if (!validate_codec_tag(s, st)) {
2985 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2986 av_log(s, AV_LOG_ERROR,
2987 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2988 tagbuf, st->codec->codec_tag, st->codec->codec_id);
2989 ret = AVERROR_INVALIDDATA;
2993 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2996 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2997 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2998 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
3001 if (!s->priv_data && s->oformat->priv_data_size > 0) {
3002 s->priv_data = av_mallocz(s->oformat->priv_data_size);
3003 if (!s->priv_data) {
3004 ret = AVERROR(ENOMEM);
3007 if (s->oformat->priv_class) {
3008 *(const AVClass**)s->priv_data= s->oformat->priv_class;
3009 av_opt_set_defaults(s->priv_data);
3010 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3015 /* set muxer identification string */
3016 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
3017 av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
3020 if(s->oformat->write_header){
3021 ret = s->oformat->write_header(s);
3026 /* init PTS generation */
3027 for(i=0;i<s->nb_streams;i++) {
3028 int64_t den = AV_NOPTS_VALUE;
3031 switch (st->codec->codec_type) {
3032 case AVMEDIA_TYPE_AUDIO:
3033 den = (int64_t)st->time_base.num * st->codec->sample_rate;
3035 case AVMEDIA_TYPE_VIDEO:
3036 den = (int64_t)st->time_base.num * st->codec->time_base.den;
3041 if (den != AV_NOPTS_VALUE) {
3043 ret = AVERROR_INVALIDDATA;
3046 frac_init(&st->pts, 0, 0, den);
3051 av_dict_free(options);
3060 //FIXME merge with compute_pkt_fields
3061 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3062 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3063 int num, den, frame_size, i;
3065 av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3066 pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3068 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
3069 return AVERROR(EINVAL);*/
3071 /* duration field */
3072 if (pkt->duration == 0) {
3073 compute_frame_duration(&num, &den, st, NULL, pkt);
3075 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3079 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3082 //XXX/FIXME this is a temporary hack until all encoders output pts
3083 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3085 // pkt->pts= st->cur_dts;
3086 pkt->pts= st->pts.val;
3089 //calculate dts from pts
3090 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3091 st->pts_buffer[0]= pkt->pts;
3092 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3093 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3094 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3095 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3097 pkt->dts= st->pts_buffer[0];
3100 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
3101 av_log(s, AV_LOG_ERROR,
3102 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3103 st->index, st->cur_dts, pkt->dts);
3104 return AVERROR(EINVAL);
3106 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3107 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3108 return AVERROR(EINVAL);
3111 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3112 st->cur_dts= pkt->dts;
3113 st->pts.val= pkt->dts;
3116 switch (st->codec->codec_type) {
3117 case AVMEDIA_TYPE_AUDIO:
3118 frame_size = get_audio_frame_size(st->codec, pkt->size);
3120 /* HACK/FIXME, we skip the initial 0 size packets as they are most
3121 likely equal to the encoder delay, but it would be better if we
3122 had the real timestamps from the encoder */
3123 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3124 frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3127 case AVMEDIA_TYPE_VIDEO:
3128 frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3136 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3141 if (s->oformat->flags & AVFMT_ALLOW_FLUSH)
3142 return s->oformat->write_packet(s, pkt);
3146 ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3148 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3151 ret= s->oformat->write_packet(s, pkt);
3154 s->streams[pkt->stream_index]->nb_frames++;
3158 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3159 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3161 AVPacketList **next_point, *this_pktl;
3163 this_pktl = av_mallocz(sizeof(AVPacketList));
3164 this_pktl->pkt= *pkt;
3165 pkt->destruct= NULL; // do not free original but only the copy
3166 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
3168 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3169 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3171 next_point = &s->packet_buffer;
3174 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3175 while(!compare(s, &(*next_point)->pkt, pkt)){
3176 next_point= &(*next_point)->next;
3180 next_point = &(s->packet_buffer_end->next);
3183 assert(!*next_point);
3185 s->packet_buffer_end= this_pktl;
3188 this_pktl->next= *next_point;
3190 s->streams[pkt->stream_index]->last_in_packet_buffer=
3191 *next_point= this_pktl;
3194 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3196 AVStream *st = s->streams[ pkt ->stream_index];
3197 AVStream *st2= s->streams[ next->stream_index];
3198 int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3202 return pkt->stream_index < next->stream_index;
3206 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3212 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3215 for(i=0; i < s->nb_streams; i++)
3216 stream_count+= !!s->streams[i]->last_in_packet_buffer;
3218 if(stream_count && (s->nb_streams == stream_count || flush)){
3219 pktl= s->packet_buffer;
3222 s->packet_buffer= pktl->next;
3223 if(!s->packet_buffer)
3224 s->packet_buffer_end= NULL;
3226 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3227 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3231 av_init_packet(out);
3237 * Interleave an AVPacket correctly so it can be muxed.
3238 * @param out the interleaved packet will be output here
3239 * @param in the input packet
3240 * @param flush 1 if no further packets are available as input and all
3241 * remaining packets should be output
3242 * @return 1 if a packet was output, 0 if no packet could be output,
3243 * < 0 if an error occurred
3245 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3246 if (s->oformat->interleave_packet) {
3247 int ret = s->oformat->interleave_packet(s, out, in, flush);
3252 return av_interleave_packet_per_dts(s, out, in, flush);
3255 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3256 AVStream *st= s->streams[ pkt->stream_index];
3259 //FIXME/XXX/HACK drop zero sized packets
3260 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3263 av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3264 pkt->size, pkt->dts, pkt->pts);
3265 if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3268 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3269 return AVERROR(EINVAL);
3273 int ret= interleave_packet(s, &opkt, pkt, 0);
3274 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3277 ret= s->oformat->write_packet(s, &opkt);
3279 s->streams[opkt.stream_index]->nb_frames++;
3281 av_free_packet(&opkt);
3289 int av_write_trailer(AVFormatContext *s)
3295 ret= interleave_packet(s, &pkt, NULL, 1);
3296 if(ret<0) //FIXME cleanup needed for ret<0 ?
3301 ret= s->oformat->write_packet(s, &pkt);
3303 s->streams[pkt.stream_index]->nb_frames++;
3305 av_free_packet(&pkt);
3311 if(s->oformat->write_trailer)
3312 ret = s->oformat->write_trailer(s);
3314 for(i=0;i<s->nb_streams;i++) {
3315 av_freep(&s->streams[i]->priv_data);
3316 av_freep(&s->streams[i]->index_entries);
3318 if (s->oformat->priv_class)
3319 av_opt_free(s->priv_data);
3320 av_freep(&s->priv_data);
3324 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3327 AVProgram *program=NULL;
3330 if (idx >= ac->nb_streams) {
3331 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3335 for(i=0; i<ac->nb_programs; i++){
3336 if(ac->programs[i]->id != progid)
3338 program = ac->programs[i];
3339 for(j=0; j<program->nb_stream_indexes; j++)
3340 if(program->stream_index[j] == idx)
3343 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3346 program->stream_index = tmp;
3347 program->stream_index[program->nb_stream_indexes++] = idx;
3352 static void print_fps(double d, const char *postfix){
3353 uint64_t v= lrintf(d*100);
3354 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3355 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3356 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3359 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3361 if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3362 AVDictionaryEntry *tag=NULL;
3364 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3365 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3366 if(strcmp("language", tag->key))
3367 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
3372 /* "user interface" functions */
3373 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3376 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3377 AVStream *st = ic->streams[i];
3378 int g = av_gcd(st->time_base.num, st->time_base.den);
3379 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3380 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3381 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
3382 /* the pid is an important information, so we display it */
3383 /* XXX: add a generic system */
3384 if (flags & AVFMT_SHOW_IDS)
3385 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3387 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3388 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3389 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3390 if (st->sample_aspect_ratio.num && // default
3391 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3392 AVRational display_aspect_ratio;
3393 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3394 st->codec->width*st->sample_aspect_ratio.num,
3395 st->codec->height*st->sample_aspect_ratio.den,
3397 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3398 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3399 display_aspect_ratio.num, display_aspect_ratio.den);
3401 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3402 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3403 print_fps(av_q2d(st->avg_frame_rate), "fps");
3404 if(st->r_frame_rate.den && st->r_frame_rate.num)
3405 print_fps(av_q2d(st->r_frame_rate), "tbr");
3406 if(st->time_base.den && st->time_base.num)
3407 print_fps(1/av_q2d(st->time_base), "tbn");
3408 if(st->codec->time_base.den && st->codec->time_base.num)
3409 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3411 if (st->disposition & AV_DISPOSITION_DEFAULT)
3412 av_log(NULL, AV_LOG_INFO, " (default)");
3413 if (st->disposition & AV_DISPOSITION_DUB)
3414 av_log(NULL, AV_LOG_INFO, " (dub)");
3415 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3416 av_log(NULL, AV_LOG_INFO, " (original)");
3417 if (st->disposition & AV_DISPOSITION_COMMENT)
3418 av_log(NULL, AV_LOG_INFO, " (comment)");
3419 if (st->disposition & AV_DISPOSITION_LYRICS)
3420 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3421 if (st->disposition & AV_DISPOSITION_KARAOKE)
3422 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3423 if (st->disposition & AV_DISPOSITION_FORCED)
3424 av_log(NULL, AV_LOG_INFO, " (forced)");
3425 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3426 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3427 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3428 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3429 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3430 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3431 av_log(NULL, AV_LOG_INFO, "\n");
3432 dump_metadata(NULL, st->metadata, " ");
3435 #if FF_API_DUMP_FORMAT
3436 void dump_format(AVFormatContext *ic,
3441 av_dump_format(ic, index, url, is_output);
3445 void av_dump_format(AVFormatContext *ic,
3451 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3452 if (ic->nb_streams && !printed)
3455 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3456 is_output ? "Output" : "Input",
3458 is_output ? ic->oformat->name : ic->iformat->name,
3459 is_output ? "to" : "from", url);
3460 dump_metadata(NULL, ic->metadata, " ");
3462 av_log(NULL, AV_LOG_INFO, " Duration: ");
3463 if (ic->duration != AV_NOPTS_VALUE) {
3464 int hours, mins, secs, us;
3465 secs = ic->duration / AV_TIME_BASE;
3466 us = ic->duration % AV_TIME_BASE;
3471 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3472 (100 * us) / AV_TIME_BASE);
3474 av_log(NULL, AV_LOG_INFO, "N/A");
3476 if (ic->start_time != AV_NOPTS_VALUE) {
3478 av_log(NULL, AV_LOG_INFO, ", start: ");
3479 secs = ic->start_time / AV_TIME_BASE;
3480 us = abs(ic->start_time % AV_TIME_BASE);
3481 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3482 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3484 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3486 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3488 av_log(NULL, AV_LOG_INFO, "N/A");
3490 av_log(NULL, AV_LOG_INFO, "\n");
3492 for (i = 0; i < ic->nb_chapters; i++) {
3493 AVChapter *ch = ic->chapters[i];
3494 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3495 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3496 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3498 dump_metadata(NULL, ch->metadata, " ");
3500 if(ic->nb_programs) {
3501 int j, k, total = 0;
3502 for(j=0; j<ic->nb_programs; j++) {
3503 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3505 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3506 name ? name->value : "");
3507 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3508 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3509 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3510 printed[ic->programs[j]->stream_index[k]] = 1;
3512 total += ic->programs[j]->nb_stream_indexes;
3514 if (total < ic->nb_streams)
3515 av_log(NULL, AV_LOG_INFO, " No Program\n");
3517 for(i=0;i<ic->nb_streams;i++)
3519 dump_stream_format(ic, i, index, is_output);
3524 int64_t av_gettime(void)
3527 gettimeofday(&tv,NULL);
3528 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3531 uint64_t ff_ntp_time(void)
3533 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3536 #if FF_API_PARSE_DATE
3537 #include "libavutil/parseutils.h"
3539 int64_t parse_date(const char *timestr, int duration)
3542 av_parse_time(&timeval, timestr, duration);
3547 #if FF_API_FIND_INFO_TAG
3548 #include "libavutil/parseutils.h"
3550 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3552 return av_find_info_tag(arg, arg_size, tag1, info);
3556 int av_get_frame_filename(char *buf, int buf_size,
3557 const char *path, int number)
3560 char *q, buf1[20], c;
3561 int nd, len, percentd_found;
3573 while (isdigit(*p)) {
3574 nd = nd * 10 + *p++ - '0';
3577 } while (isdigit(c));
3586 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3588 if ((q - buf + len) > buf_size - 1)
3590 memcpy(q, buf1, len);
3598 if ((q - buf) < buf_size - 1)
3602 if (!percentd_found)
3611 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3615 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3617 for(i=0;i<size;i+=16) {
3624 PRINT(" %02x", buf[i+j]);
3629 for(j=0;j<len;j++) {
3631 if (c < ' ' || c > '~')
3640 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3642 hex_dump_internal(NULL, f, 0, buf, size);