2 * various utility functions for use within FFmpeg
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg 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 * FFmpeg 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 FFmpeg; 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/raw.h"
29 #include "libavutil/opt.h"
30 #include "libavutil/dict.h"
31 #include "libavutil/pixdesc.h"
34 #include "libavutil/avstring.h"
35 #include "libavutil/mathematics.h"
37 #include "audiointerleave.h"
52 * various utility functions for use within FFmpeg
55 unsigned avformat_version(void)
57 return LIBAVFORMAT_VERSION_INT;
60 const char *avformat_configuration(void)
62 return FFMPEG_CONFIGURATION;
65 const char *avformat_license(void)
67 #define LICENSE_PREFIX "libavformat license: "
68 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
71 /* fraction handling */
74 * f = val + (num / den) + 0.5.
76 * 'num' is normalized so that it is such as 0 <= num < den.
78 * @param f fractional number
79 * @param val integer value
80 * @param num must be >= 0
81 * @param den must be >= 1
83 static void frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
96 * Fractional addition to f: f = f + (incr / f->den).
98 * @param f fractional number
99 * @param incr increment, can be positive or negative
101 static void frac_add(AVFrac *f, int64_t incr)
114 } else if (num >= den) {
121 /** head of registered input format linked list */
122 static AVInputFormat *first_iformat = NULL;
123 /** head of registered output format linked list */
124 static AVOutputFormat *first_oformat = NULL;
126 AVInputFormat *av_iformat_next(AVInputFormat *f)
128 if(f) return f->next;
129 else return first_iformat;
132 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
134 if(f) return f->next;
135 else return first_oformat;
138 void av_register_input_format(AVInputFormat *format)
142 while (*p != NULL) p = &(*p)->next;
147 void av_register_output_format(AVOutputFormat *format)
151 while (*p != NULL) p = &(*p)->next;
156 int av_match_ext(const char *filename, const char *extensions)
164 ext = strrchr(filename, '.');
170 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
173 if (!strcasecmp(ext1, ext))
183 static int match_format(const char *name, const char *names)
191 namelen = strlen(name);
192 while ((p = strchr(names, ','))) {
193 len = FFMAX(p - names, namelen);
194 if (!strncasecmp(name, names, len))
198 return !strcasecmp(name, names);
201 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
202 const char *mime_type)
204 AVOutputFormat *fmt = NULL, *fmt_found;
205 int score_max, score;
207 /* specific test for image sequences */
208 #if CONFIG_IMAGE2_MUXER
209 if (!short_name && filename &&
210 av_filename_number_test(filename) &&
211 ff_guess_image2_codec(filename) != CODEC_ID_NONE) {
212 return av_guess_format("image2", NULL, NULL);
215 /* Find the proper file type. */
218 while ((fmt = av_oformat_next(fmt))) {
220 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
222 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
224 if (filename && fmt->extensions &&
225 av_match_ext(filename, fmt->extensions)) {
228 if (score > score_max) {
236 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
237 const char *filename, const char *mime_type, enum AVMediaType type){
238 if(type == AVMEDIA_TYPE_VIDEO){
239 enum CodecID codec_id= CODEC_ID_NONE;
241 #if CONFIG_IMAGE2_MUXER
242 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
243 codec_id= ff_guess_image2_codec(filename);
246 if(codec_id == CODEC_ID_NONE)
247 codec_id= fmt->video_codec;
249 }else if(type == AVMEDIA_TYPE_AUDIO)
250 return fmt->audio_codec;
251 else if (type == AVMEDIA_TYPE_SUBTITLE)
252 return fmt->subtitle_codec;
254 return CODEC_ID_NONE;
257 AVInputFormat *av_find_input_format(const char *short_name)
259 AVInputFormat *fmt = NULL;
260 while ((fmt = av_iformat_next(fmt))) {
261 if (match_format(short_name, fmt->name))
268 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
270 int ret= av_new_packet(pkt, size);
275 pkt->pos= avio_tell(s);
277 ret= avio_read(s, pkt->data, size);
281 av_shrink_packet(pkt, ret);
286 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
291 return av_get_packet(s, pkt, size);
292 old_size = pkt->size;
293 ret = av_grow_packet(pkt, size);
296 ret = avio_read(s, pkt->data + old_size, size);
297 av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
302 int av_filename_number_test(const char *filename)
305 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
308 AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened, int *score_ret)
310 AVProbeData lpd = *pd;
311 AVInputFormat *fmt1 = NULL, *fmt;
312 int score, score_max=0;
314 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
315 int id3len = ff_id3v2_tag_len(lpd.buf);
316 if (lpd.buf_size > id3len + 16) {
318 lpd.buf_size -= id3len;
323 while ((fmt1 = av_iformat_next(fmt1))) {
324 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
327 if (fmt1->read_probe) {
328 score = fmt1->read_probe(&lpd);
329 if(!score && fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
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)
342 *score_ret= score_max;
346 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
349 AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
350 if(score_ret > *score_max){
351 *score_max= score_ret;
357 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
359 return av_probe_input_format2(pd, is_opened, &score);
362 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
364 static const struct {
365 const char *name; enum CodecID id; enum AVMediaType type;
367 { "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
368 { "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
369 { "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
370 { "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
371 { "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
372 { "loas" , CODEC_ID_AAC_LATM , AVMEDIA_TYPE_AUDIO },
373 { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
374 { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
375 { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
379 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
383 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
384 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
385 for (i = 0; fmt_id_type[i].name; i++) {
386 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
387 st->codec->codec_id = fmt_id_type[i].id;
388 st->codec->codec_type = fmt_id_type[i].type;
396 /************************************************************/
397 /* input media file */
399 #if FF_API_FORMAT_PARAMETERS
400 static AVDictionary *convert_format_parameters(AVFormatParameters *ap)
403 AVDictionary *opts = NULL;
408 if (ap->time_base.num) {
409 snprintf(buf, sizeof(buf), "%d/%d", ap->time_base.den, ap->time_base.num);
410 av_dict_set(&opts, "framerate", buf, 0);
412 if (ap->sample_rate) {
413 snprintf(buf, sizeof(buf), "%d", ap->sample_rate);
414 av_dict_set(&opts, "sample_rate", buf, 0);
417 snprintf(buf, sizeof(buf), "%d", ap->channels);
418 av_dict_set(&opts, "channels", buf, 0);
420 if (ap->width || ap->height) {
421 snprintf(buf, sizeof(buf), "%dx%d", ap->width, ap->height);
422 av_dict_set(&opts, "video_size", buf, 0);
424 if (ap->pix_fmt != PIX_FMT_NONE) {
425 av_dict_set(&opts, "pixel_format", av_get_pix_fmt_name(ap->pix_fmt), 0);
428 snprintf(buf, sizeof(buf), "%d", ap->channel);
429 av_dict_set(&opts, "channel", buf, 0);
432 av_dict_set(&opts, "standard", ap->standard, 0);
434 if (ap->mpeg2ts_compute_pcr) {
435 av_dict_set(&opts, "mpeg2ts_compute_pcr", "1", 0);
437 if (ap->initial_pause) {
438 av_dict_set(&opts, "initial_pause", "1", 0);
444 * Open a media file from an IO stream. 'fmt' must be specified.
446 int av_open_input_stream(AVFormatContext **ic_ptr,
447 AVIOContext *pb, const char *filename,
448 AVInputFormat *fmt, AVFormatParameters *ap)
453 AVFormatParameters default_ap;
457 memset(ap, 0, sizeof(default_ap));
459 opts = convert_format_parameters(ap);
461 if(!ap->prealloced_context)
462 *ic_ptr = ic = avformat_alloc_context();
466 err = AVERROR(ENOMEM);
469 if (pb && fmt && fmt->flags & AVFMT_NOFILE)
470 av_log(ic, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
471 "will be ignored with AVFMT_NOFILE format.\n");
475 if ((err = avformat_open_input(&ic, filename, fmt, &opts)) < 0)
477 ic->pb = ic->pb ? ic->pb : pb; // don't leak custom pb if it wasn't set above
486 int av_demuxer_open(AVFormatContext *ic, AVFormatParameters *ap){
489 if (ic->iformat->read_header) {
490 err = ic->iformat->read_header(ic, ap);
495 if (ic->pb && !ic->data_offset)
496 ic->data_offset = avio_tell(ic->pb);
502 /** size of probe buffer, for guessing file type from file contents */
503 #define PROBE_BUF_MIN 2048
504 #define PROBE_BUF_MAX (1<<20)
506 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
507 const char *filename, void *logctx,
508 unsigned int offset, unsigned int max_probe_size)
510 AVProbeData pd = { filename ? filename : "", NULL, -offset };
511 unsigned char *buf = NULL;
512 int ret = 0, probe_size;
514 if (!max_probe_size) {
515 max_probe_size = PROBE_BUF_MAX;
516 } else if (max_probe_size > PROBE_BUF_MAX) {
517 max_probe_size = PROBE_BUF_MAX;
518 } else if (max_probe_size < PROBE_BUF_MIN) {
519 return AVERROR(EINVAL);
522 if (offset >= max_probe_size) {
523 return AVERROR(EINVAL);
526 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
527 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
528 int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
529 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
532 if (probe_size < offset) {
536 /* read probe data */
537 buftmp = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
540 return AVERROR(ENOMEM);
543 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
544 /* fail if error was not end of file, otherwise, lower score */
545 if (ret != AVERROR_EOF) {
550 ret = 0; /* error was end of file, nothing read */
553 pd.buf = &buf[offset];
555 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
557 /* guess file format */
558 *fmt = av_probe_input_format2(&pd, 1, &score);
560 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
561 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
563 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
569 return AVERROR_INVALIDDATA;
572 /* rewind. reuse probe buffer to avoid seeking */
573 if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
579 #if FF_API_FORMAT_PARAMETERS
580 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
583 AVFormatParameters *ap)
586 AVDictionary *opts = convert_format_parameters(ap);
588 if (!ap || !ap->prealloced_context)
591 err = avformat_open_input(ic_ptr, filename, fmt, &opts);
598 /* open input file and probe the format if necessary */
599 static int init_input(AVFormatContext *s, const char *filename)
602 AVProbeData pd = {filename, NULL, 0};
605 s->flags |= AVFMT_FLAG_CUSTOM_IO;
607 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
608 else if (s->iformat->flags & AVFMT_NOFILE)
609 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
610 "will be ignored with AVFMT_NOFILE format.\n");
614 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
615 (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
618 if ((ret = avio_open(&s->pb, filename, AVIO_FLAG_READ)) < 0)
622 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
625 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
627 AVFormatContext *s = *ps;
629 AVFormatParameters ap = { { 0 } };
630 AVDictionary *tmp = NULL;
632 if (!s && !(s = avformat_alloc_context()))
633 return AVERROR(ENOMEM);
638 av_dict_copy(&tmp, *options, 0);
640 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
643 if ((ret = init_input(s, filename)) < 0)
646 /* check filename in case an image number is expected */
647 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
648 if (!av_filename_number_test(filename)) {
649 ret = AVERROR(EINVAL);
654 s->duration = s->start_time = AV_NOPTS_VALUE;
655 av_strlcpy(s->filename, filename, sizeof(s->filename));
657 /* allocate private data */
658 if (s->iformat->priv_data_size > 0) {
659 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
660 ret = AVERROR(ENOMEM);
663 if (s->iformat->priv_class) {
664 *(const AVClass**)s->priv_data = s->iformat->priv_class;
665 av_opt_set_defaults(s->priv_data);
666 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
671 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
673 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC);
675 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
676 if ((ret = s->iformat->read_header(s, &ap)) < 0)
679 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
680 s->data_offset = avio_tell(s->pb);
682 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
685 av_dict_free(options);
693 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
695 avformat_free_context(s);
700 /*******************************************************/
702 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
703 AVPacketList **plast_pktl){
704 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
709 (*plast_pktl)->next = pktl;
711 *packet_buffer = pktl;
713 /* add the packet in the buffered packet list */
719 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
725 AVPacketList *pktl = s->raw_packet_buffer;
729 if(s->streams[pkt->stream_index]->request_probe <= 0){
730 s->raw_packet_buffer = pktl->next;
731 s->raw_packet_buffer_remaining_size += pkt->size;
738 ret= s->iformat->read_packet(s, pkt);
740 if (!pktl || ret == AVERROR(EAGAIN))
742 for (i = 0; i < s->nb_streams; i++)
743 if(s->streams[i]->request_probe > 0)
744 s->streams[i]->request_probe = -1;
748 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
749 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
750 av_log(s, AV_LOG_WARNING,
751 "Dropped corrupted packet (stream = %d)\n",
756 if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
757 av_packet_merge_side_data(pkt);
759 st= s->streams[pkt->stream_index];
761 switch(st->codec->codec_type){
762 case AVMEDIA_TYPE_VIDEO:
763 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
765 case AVMEDIA_TYPE_AUDIO:
766 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
768 case AVMEDIA_TYPE_SUBTITLE:
769 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
773 if(!pktl && st->request_probe <= 0)
776 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
777 s->raw_packet_buffer_remaining_size -= pkt->size;
779 if(st->request_probe>0){
780 AVProbeData *pd = &st->probe_data;
782 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
785 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
786 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
787 pd->buf_size += pkt->size;
788 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
790 end= s->raw_packet_buffer_remaining_size <= 0
791 || st->probe_packets<=0;
793 if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
794 int score= set_codec_from_probe_data(s, st, pd);
795 if( (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
799 st->request_probe= -1;
800 if(st->codec->codec_id != CODEC_ID_NONE){
801 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
803 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
810 /**********************************************************/
813 * Get the number of samples of an audio frame. Return -1 on error.
815 static int get_audio_frame_size(AVCodecContext *enc, int size)
819 if(enc->codec_id == CODEC_ID_VORBIS)
822 if (enc->frame_size <= 1) {
823 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
825 if (bits_per_sample) {
826 if (enc->channels == 0)
828 frame_size = (size << 3) / (bits_per_sample * enc->channels);
830 /* used for example by ADPCM codecs */
831 if (enc->bit_rate == 0)
833 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
836 frame_size = enc->frame_size;
843 * Return the frame duration in seconds. Return 0 if not available.
845 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
846 AVCodecParserContext *pc, AVPacket *pkt)
852 switch(st->codec->codec_type) {
853 case AVMEDIA_TYPE_VIDEO:
854 if(st->time_base.num*1000LL > st->time_base.den){
855 *pnum = st->time_base.num;
856 *pden = st->time_base.den;
857 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
858 *pnum = st->codec->time_base.num;
859 *pden = st->codec->time_base.den;
860 if (pc && pc->repeat_pict) {
861 *pnum = (*pnum) * (1 + pc->repeat_pict);
863 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
864 //Thus if we have no parser in such case leave duration undefined.
865 if(st->codec->ticks_per_frame>1 && !pc){
870 case AVMEDIA_TYPE_AUDIO:
871 frame_size = get_audio_frame_size(st->codec, pkt->size);
872 if (frame_size <= 0 || st->codec->sample_rate <= 0)
875 *pden = st->codec->sample_rate;
882 static int is_intra_only(AVCodecContext *enc){
883 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
885 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
886 switch(enc->codec_id){
888 case CODEC_ID_MJPEGB:
890 case CODEC_ID_RAWVIDEO:
891 case CODEC_ID_DVVIDEO:
892 case CODEC_ID_HUFFYUV:
893 case CODEC_ID_FFVHUFF:
898 case CODEC_ID_JPEG2000:
899 case CODEC_ID_PRORES:
907 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
908 int64_t dts, int64_t pts)
910 AVStream *st= s->streams[stream_index];
911 AVPacketList *pktl= s->packet_buffer;
913 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
916 st->first_dts= dts - st->cur_dts;
919 for(; pktl; pktl= pktl->next){
920 if(pktl->pkt.stream_index != stream_index)
922 //FIXME think more about this check
923 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
924 pktl->pkt.pts += st->first_dts;
926 if(pktl->pkt.dts != AV_NOPTS_VALUE)
927 pktl->pkt.dts += st->first_dts;
929 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
930 st->start_time= pktl->pkt.pts;
932 if (st->start_time == AV_NOPTS_VALUE)
933 st->start_time = pts;
936 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
938 AVPacketList *pktl= s->packet_buffer;
941 if(st->first_dts != AV_NOPTS_VALUE){
942 cur_dts= st->first_dts;
943 for(; pktl; pktl= pktl->next){
944 if(pktl->pkt.stream_index == pkt->stream_index){
945 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
947 cur_dts -= pkt->duration;
950 pktl= s->packet_buffer;
951 st->first_dts = cur_dts;
952 }else if(st->cur_dts)
955 for(; pktl; pktl= pktl->next){
956 if(pktl->pkt.stream_index != pkt->stream_index)
958 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
959 && !pktl->pkt.duration){
960 pktl->pkt.dts= cur_dts;
961 if(!st->codec->has_b_frames)
962 pktl->pkt.pts= cur_dts;
963 cur_dts += pkt->duration;
964 pktl->pkt.duration= pkt->duration;
968 if(st->first_dts == AV_NOPTS_VALUE)
969 st->cur_dts= cur_dts;
972 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
973 AVCodecParserContext *pc, AVPacket *pkt)
975 int num, den, presentation_delayed, delay, i;
978 if (s->flags & AVFMT_FLAG_NOFILLIN)
981 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
982 pkt->dts= AV_NOPTS_VALUE;
984 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
985 //FIXME Set low_delay = 0 when has_b_frames = 1
986 st->codec->has_b_frames = 1;
988 /* do we have a video B-frame ? */
989 delay= st->codec->has_b_frames;
990 presentation_delayed = 0;
992 // ignore delay caused by frame threading so that the mpeg2-without-dts
993 // warning will not trigger
994 if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
995 delay -= st->codec->thread_count-1;
997 /* XXX: need has_b_frame, but cannot get it if the codec is
1000 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1001 presentation_delayed = 1;
1003 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
1004 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
1005 pkt->dts -= 1LL<<st->pts_wrap_bits;
1008 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
1009 // we take the conservative approach and discard both
1010 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
1011 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
1012 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %Ld\n", pkt->dts);
1013 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
1016 if (pkt->duration == 0) {
1017 compute_frame_duration(&num, &den, st, pc, pkt);
1019 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1021 if(pkt->duration != 0 && s->packet_buffer)
1022 update_initial_durations(s, st, pkt);
1026 /* correct timestamps with byte offset if demuxers only have timestamps
1027 on packet boundaries */
1028 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1029 /* this will estimate bitrate based on this frame's duration and size */
1030 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1031 if(pkt->pts != AV_NOPTS_VALUE)
1033 if(pkt->dts != AV_NOPTS_VALUE)
1037 if (pc && pc->dts_sync_point >= 0) {
1038 // we have synchronization info from the parser
1039 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1041 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1042 if (pkt->dts != AV_NOPTS_VALUE) {
1043 // got DTS from the stream, update reference timestamp
1044 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1045 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1046 } else if (st->reference_dts != AV_NOPTS_VALUE) {
1047 // compute DTS based on reference timestamp
1048 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1049 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1051 if (pc->dts_sync_point > 0)
1052 st->reference_dts = pkt->dts; // new reference
1056 /* This may be redundant, but it should not hurt. */
1057 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1058 presentation_delayed = 1;
1060 // 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);
1061 /* interpolate PTS and DTS if they are not present */
1062 //We skip H264 currently because delay and has_b_frames are not reliably set
1063 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1064 if (presentation_delayed) {
1065 /* DTS = decompression timestamp */
1066 /* PTS = presentation timestamp */
1067 if (pkt->dts == AV_NOPTS_VALUE)
1068 pkt->dts = st->last_IP_pts;
1069 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1070 if (pkt->dts == AV_NOPTS_VALUE)
1071 pkt->dts = st->cur_dts;
1073 /* this is tricky: the dts must be incremented by the duration
1074 of the frame we are displaying, i.e. the last I- or P-frame */
1075 if (st->last_IP_duration == 0)
1076 st->last_IP_duration = pkt->duration;
1077 if(pkt->dts != AV_NOPTS_VALUE)
1078 st->cur_dts = pkt->dts + st->last_IP_duration;
1079 st->last_IP_duration = pkt->duration;
1080 st->last_IP_pts= pkt->pts;
1081 /* cannot compute PTS if not present (we can compute it only
1082 by knowing the future */
1083 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1084 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1085 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1086 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1087 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1088 pkt->pts += pkt->duration;
1089 // 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);
1093 /* presentation is not delayed : PTS and DTS are the same */
1094 if(pkt->pts == AV_NOPTS_VALUE)
1095 pkt->pts = pkt->dts;
1096 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1097 if(pkt->pts == AV_NOPTS_VALUE)
1098 pkt->pts = st->cur_dts;
1099 pkt->dts = pkt->pts;
1100 if(pkt->pts != AV_NOPTS_VALUE)
1101 st->cur_dts = pkt->pts + pkt->duration;
1105 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1106 st->pts_buffer[0]= pkt->pts;
1107 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1108 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1109 if(pkt->dts == AV_NOPTS_VALUE)
1110 pkt->dts= st->pts_buffer[0];
1111 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1112 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1114 if(pkt->dts > st->cur_dts)
1115 st->cur_dts = pkt->dts;
1118 // 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);
1121 if(is_intra_only(st->codec))
1122 pkt->flags |= AV_PKT_FLAG_KEY;
1125 /* keyframe computation */
1126 if (pc->key_frame == 1)
1127 pkt->flags |= AV_PKT_FLAG_KEY;
1128 else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
1129 pkt->flags |= AV_PKT_FLAG_KEY;
1132 pkt->convergence_duration = pc->convergence_duration;
1136 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1141 av_init_packet(pkt);
1144 /* select current input stream component */
1147 if (!st->need_parsing || !st->parser) {
1148 /* no parsing needed: we just output the packet as is */
1149 /* raw data support */
1151 st->cur_pkt.data= NULL;
1152 st->cur_pkt.side_data_elems = 0;
1153 st->cur_pkt.side_data = NULL;
1154 compute_pkt_fields(s, st, NULL, pkt);
1156 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1157 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1158 ff_reduce_index(s, st->index);
1159 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1162 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1163 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1164 st->cur_ptr, st->cur_len,
1165 st->cur_pkt.pts, st->cur_pkt.dts,
1167 st->cur_pkt.pts = AV_NOPTS_VALUE;
1168 st->cur_pkt.dts = AV_NOPTS_VALUE;
1169 /* increment read pointer */
1173 /* return packet if any */
1177 pkt->stream_index = st->index;
1178 pkt->pts = st->parser->pts;
1179 pkt->dts = st->parser->dts;
1180 pkt->pos = st->parser->pos;
1181 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1183 pkt->destruct= st->cur_pkt.destruct;
1184 st->cur_pkt.destruct= NULL;
1185 st->cur_pkt.data = NULL;
1186 assert(st->cur_len == 0);
1188 pkt->destruct = NULL;
1190 compute_pkt_fields(s, st, st->parser, pkt);
1192 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1193 int64_t pos= (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->pos : st->parser->frame_offset;
1194 ff_reduce_index(s, st->index);
1195 av_add_index_entry(st, pos, pkt->dts,
1196 0, 0, AVINDEX_KEYFRAME);
1203 av_free_packet(&st->cur_pkt);
1208 /* read next packet */
1209 ret = av_read_packet(s, &cur_pkt);
1211 if (ret == AVERROR(EAGAIN))
1213 /* return the last frames, if any */
1214 for(i = 0; i < s->nb_streams; i++) {
1216 if (st->parser && st->need_parsing) {
1217 av_parser_parse2(st->parser, st->codec,
1218 &pkt->data, &pkt->size,
1220 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1226 /* no more packets: really terminate parsing */
1229 st = s->streams[cur_pkt.stream_index];
1230 st->cur_pkt= cur_pkt;
1232 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1233 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1234 st->cur_pkt.pts < st->cur_pkt.dts){
1235 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1236 st->cur_pkt.stream_index,
1240 // av_free_packet(&st->cur_pkt);
1244 if(s->debug & FF_FDEBUG_TS)
1245 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1246 st->cur_pkt.stream_index,
1250 st->cur_pkt.duration,
1254 st->cur_ptr = st->cur_pkt.data;
1255 st->cur_len = st->cur_pkt.size;
1256 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1257 st->parser = av_parser_init(st->codec->codec_id);
1259 av_log(s, AV_LOG_WARNING, "parser not found for codec "
1260 "%s, packets or times may be invalid.\n",
1261 avcodec_get_name(st->codec->codec_id));
1262 /* no parser available: just output the raw packets */
1263 st->need_parsing = AVSTREAM_PARSE_NONE;
1264 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1265 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1266 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1267 st->parser->flags |= PARSER_FLAG_ONCE;
1272 if(s->debug & FF_FDEBUG_TS)
1273 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1284 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1288 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1291 pktl = s->packet_buffer;
1293 AVPacket *next_pkt= &pktl->pkt;
1295 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1296 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1297 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1298 if( pktl->pkt.stream_index == next_pkt->stream_index
1299 && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1300 && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1301 next_pkt->pts= pktl->pkt.dts;
1305 pktl = s->packet_buffer;
1308 if( next_pkt->pts != AV_NOPTS_VALUE
1309 || next_pkt->dts == AV_NOPTS_VALUE
1311 /* read packet from packet buffer, if there is data */
1313 s->packet_buffer = pktl->next;
1319 int ret= read_frame_internal(s, pkt);
1321 if(pktl && ret != AVERROR(EAGAIN)){
1328 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1329 &s->packet_buffer_end)) < 0)
1330 return AVERROR(ENOMEM);
1332 assert(!s->packet_buffer);
1333 return read_frame_internal(s, pkt);
1338 /* XXX: suppress the packet queue */
1339 static void flush_packet_queue(AVFormatContext *s)
1344 pktl = s->packet_buffer;
1347 s->packet_buffer = pktl->next;
1348 av_free_packet(&pktl->pkt);
1351 while(s->raw_packet_buffer){
1352 pktl = s->raw_packet_buffer;
1353 s->raw_packet_buffer = pktl->next;
1354 av_free_packet(&pktl->pkt);
1357 s->packet_buffer_end=
1358 s->raw_packet_buffer_end= NULL;
1359 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1362 /*******************************************************/
1365 int av_find_default_stream_index(AVFormatContext *s)
1367 int first_audio_index = -1;
1371 if (s->nb_streams <= 0)
1373 for(i = 0; i < s->nb_streams; i++) {
1375 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1378 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1379 first_audio_index = i;
1381 return first_audio_index >= 0 ? first_audio_index : 0;
1385 * Flush the frame reader.
1387 void ff_read_frame_flush(AVFormatContext *s)
1392 flush_packet_queue(s);
1396 /* for each stream, reset read state */
1397 for(i = 0; i < s->nb_streams; i++) {
1401 av_parser_close(st->parser);
1403 av_free_packet(&st->cur_pkt);
1405 st->last_IP_pts = AV_NOPTS_VALUE;
1406 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1407 st->reference_dts = AV_NOPTS_VALUE;
1412 st->probe_packets = MAX_PROBE_PACKETS;
1414 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1415 st->pts_buffer[j]= AV_NOPTS_VALUE;
1419 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1422 for(i = 0; i < s->nb_streams; i++) {
1423 AVStream *st = s->streams[i];
1425 st->cur_dts = av_rescale(timestamp,
1426 st->time_base.den * (int64_t)ref_st->time_base.num,
1427 st->time_base.num * (int64_t)ref_st->time_base.den);
1431 void ff_reduce_index(AVFormatContext *s, int stream_index)
1433 AVStream *st= s->streams[stream_index];
1434 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1436 if((unsigned)st->nb_index_entries >= max_entries){
1438 for(i=0; 2*i<st->nb_index_entries; i++)
1439 st->index_entries[i]= st->index_entries[2*i];
1440 st->nb_index_entries= i;
1444 int ff_add_index_entry(AVIndexEntry **index_entries,
1445 int *nb_index_entries,
1446 unsigned int *index_entries_allocated_size,
1447 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1449 AVIndexEntry *entries, *ie;
1452 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1455 entries = av_fast_realloc(*index_entries,
1456 index_entries_allocated_size,
1457 (*nb_index_entries + 1) *
1458 sizeof(AVIndexEntry));
1462 *index_entries= entries;
1464 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1467 index= (*nb_index_entries)++;
1468 ie= &entries[index];
1469 assert(index==0 || ie[-1].timestamp < timestamp);
1471 ie= &entries[index];
1472 if(ie->timestamp != timestamp){
1473 if(ie->timestamp <= timestamp)
1475 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1476 (*nb_index_entries)++;
1477 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1478 distance= ie->min_distance;
1482 ie->timestamp = timestamp;
1483 ie->min_distance= distance;
1490 int av_add_index_entry(AVStream *st,
1491 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1493 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1494 &st->index_entries_allocated_size, pos,
1495 timestamp, size, distance, flags);
1498 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1499 int64_t wanted_timestamp, int flags)
1507 //optimize appending index entries at the end
1508 if(b && entries[b-1].timestamp < wanted_timestamp)
1513 timestamp = entries[m].timestamp;
1514 if(timestamp >= wanted_timestamp)
1516 if(timestamp <= wanted_timestamp)
1519 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1521 if(!(flags & AVSEEK_FLAG_ANY)){
1522 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1523 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1532 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1535 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1536 wanted_timestamp, flags);
1539 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1540 AVInputFormat *avif= s->iformat;
1541 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1542 int64_t ts_min, ts_max, ts;
1547 if (stream_index < 0)
1550 av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1553 ts_min= AV_NOPTS_VALUE;
1554 pos_limit= -1; //gcc falsely says it may be uninitialized
1556 st= s->streams[stream_index];
1557 if(st->index_entries){
1560 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()
1561 index= FFMAX(index, 0);
1562 e= &st->index_entries[index];
1564 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1566 ts_min= e->timestamp;
1567 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1573 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1574 assert(index < st->nb_index_entries);
1576 e= &st->index_entries[index];
1577 assert(e->timestamp >= target_ts);
1579 ts_max= e->timestamp;
1580 pos_limit= pos_max - e->min_distance;
1581 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1582 pos_max,pos_limit, ts_max);
1586 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1591 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1594 av_update_cur_dts(s, st, ts);
1599 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1601 int64_t start_pos, filesize;
1604 av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1606 if(ts_min == AV_NOPTS_VALUE){
1607 pos_min = s->data_offset;
1608 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1609 if (ts_min == AV_NOPTS_VALUE)
1613 if(ts_max == AV_NOPTS_VALUE){
1615 filesize = avio_size(s->pb);
1616 pos_max = filesize - 1;
1619 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1621 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1622 if (ts_max == AV_NOPTS_VALUE)
1626 int64_t tmp_pos= pos_max + 1;
1627 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1628 if(tmp_ts == AV_NOPTS_VALUE)
1632 if(tmp_pos >= filesize)
1638 if(ts_min > ts_max){
1640 }else if(ts_min == ts_max){
1645 while (pos_min < pos_limit) {
1646 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1647 pos_min, pos_max, ts_min, ts_max);
1648 assert(pos_limit <= pos_max);
1651 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1652 // interpolate position (better than dichotomy)
1653 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1654 + pos_min - approximate_keyframe_distance;
1655 }else if(no_change==1){
1656 // bisection, if interpolation failed to change min or max pos last time
1657 pos = (pos_min + pos_limit)>>1;
1659 /* linear search if bisection failed, can only happen if there
1660 are very few or no keyframes between min/max */
1665 else if(pos > pos_limit)
1669 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1674 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1675 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1676 pos_limit, start_pos, no_change);
1677 if(ts == AV_NOPTS_VALUE){
1678 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1681 assert(ts != AV_NOPTS_VALUE);
1682 if (target_ts <= ts) {
1683 pos_limit = start_pos - 1;
1687 if (target_ts >= ts) {
1693 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1694 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1696 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1698 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1699 av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1700 pos, ts_min, target_ts, ts_max);
1705 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1706 int64_t pos_min, pos_max;
1710 if (stream_index < 0)
1713 st= s->streams[stream_index];
1716 pos_min = s->data_offset;
1717 pos_max = avio_size(s->pb) - 1;
1719 if (pos < pos_min) pos= pos_min;
1720 else if(pos > pos_max) pos= pos_max;
1722 avio_seek(s->pb, pos, SEEK_SET);
1725 av_update_cur_dts(s, st, ts);
1730 static int seek_frame_generic(AVFormatContext *s,
1731 int stream_index, int64_t timestamp, int flags)
1738 st = s->streams[stream_index];
1740 index = av_index_search_timestamp(st, timestamp, flags);
1742 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1745 if(index < 0 || index==st->nb_index_entries-1){
1748 if(st->nb_index_entries){
1749 assert(st->index_entries);
1750 ie= &st->index_entries[st->nb_index_entries-1];
1751 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1753 av_update_cur_dts(s, st, ie->timestamp);
1755 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1761 read_status = av_read_frame(s, &pkt);
1762 } while (read_status == AVERROR(EAGAIN));
1763 if (read_status < 0)
1765 av_free_packet(&pkt);
1766 if(stream_index == pkt.stream_index){
1767 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1771 index = av_index_search_timestamp(st, timestamp, flags);
1776 ff_read_frame_flush(s);
1777 if (s->iformat->read_seek){
1778 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1781 ie = &st->index_entries[index];
1782 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1784 av_update_cur_dts(s, st, ie->timestamp);
1789 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1794 ff_read_frame_flush(s);
1796 if(flags & AVSEEK_FLAG_BYTE)
1797 return seek_frame_byte(s, stream_index, timestamp, flags);
1799 if(stream_index < 0){
1800 stream_index= av_find_default_stream_index(s);
1801 if(stream_index < 0)
1804 st= s->streams[stream_index];
1805 /* timestamp for default must be expressed in AV_TIME_BASE units */
1806 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1809 /* first, we try the format specific seek */
1810 if (s->iformat->read_seek)
1811 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1818 if(s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH))
1819 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1820 else if (!(s->iformat->flags & AVFMT_NOGENSEARCH))
1821 return seek_frame_generic(s, stream_index, timestamp, flags);
1826 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1828 if(min_ts > ts || max_ts < ts)
1831 ff_read_frame_flush(s);
1833 if (s->iformat->read_seek2)
1834 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1836 if(s->iformat->read_timestamp){
1837 //try to seek via read_timestamp()
1840 //Fallback to old API if new is not implemented but old is
1841 //Note the old has somewat different sematics
1842 if(s->iformat->read_seek || 1)
1843 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1845 // try some generic seek like seek_frame_generic() but with new ts semantics
1848 /*******************************************************/
1851 * Return TRUE if the stream has accurate duration in any stream.
1853 * @return TRUE if the stream has accurate duration for at least one component.
1855 static int has_duration(AVFormatContext *ic)
1859 if(ic->duration != AV_NOPTS_VALUE)
1862 for(i = 0;i < ic->nb_streams; i++) {
1863 st = ic->streams[i];
1864 if (st->duration != AV_NOPTS_VALUE)
1871 * Estimate the stream timings from the one of each components.
1873 * Also computes the global bitrate if possible.
1875 static void update_stream_timings(AVFormatContext *ic)
1877 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
1878 int64_t duration, duration1;
1882 start_time = INT64_MAX;
1883 start_time_text = INT64_MAX;
1884 end_time = INT64_MIN;
1885 duration = INT64_MIN;
1886 for(i = 0;i < ic->nb_streams; i++) {
1887 st = ic->streams[i];
1888 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1889 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1890 if (st->codec->codec_id == CODEC_ID_DVB_TELETEXT) {
1891 if (start_time1 < start_time_text)
1892 start_time_text = start_time1;
1894 if (start_time1 < start_time)
1895 start_time = start_time1;
1896 if (st->duration != AV_NOPTS_VALUE) {
1897 end_time1 = start_time1
1898 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1899 if (end_time1 > end_time)
1900 end_time = end_time1;
1903 if (st->duration != AV_NOPTS_VALUE) {
1904 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1905 if (duration1 > duration)
1906 duration = duration1;
1909 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
1910 start_time = start_time_text;
1911 if (start_time != INT64_MAX) {
1912 ic->start_time = start_time;
1913 if (end_time != INT64_MIN) {
1914 if (end_time - start_time > duration)
1915 duration = end_time - start_time;
1918 if (duration != INT64_MIN && ic->duration == AV_NOPTS_VALUE) {
1919 ic->duration = duration;
1921 if (ic->file_size > 0 && ic->duration != AV_NOPTS_VALUE) {
1922 /* compute the bitrate */
1923 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1924 (double)ic->duration;
1928 static void fill_all_stream_timings(AVFormatContext *ic)
1933 update_stream_timings(ic);
1934 for(i = 0;i < ic->nb_streams; i++) {
1935 st = ic->streams[i];
1936 if (st->start_time == AV_NOPTS_VALUE) {
1937 if(ic->start_time != AV_NOPTS_VALUE)
1938 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1939 if(ic->duration != AV_NOPTS_VALUE)
1940 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1945 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1947 int64_t filesize, duration;
1951 /* if bit_rate is already set, we believe it */
1952 if (ic->bit_rate <= 0) {
1954 for(i=0;i<ic->nb_streams;i++) {
1955 st = ic->streams[i];
1956 if (st->codec->bit_rate > 0)
1957 bit_rate += st->codec->bit_rate;
1959 ic->bit_rate = bit_rate;
1962 /* if duration is already set, we believe it */
1963 if (ic->duration == AV_NOPTS_VALUE &&
1964 ic->bit_rate != 0 &&
1965 ic->file_size != 0) {
1966 filesize = ic->file_size;
1968 for(i = 0; i < ic->nb_streams; i++) {
1969 st = ic->streams[i];
1970 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1971 if (st->duration == AV_NOPTS_VALUE)
1972 st->duration = duration;
1978 #define DURATION_MAX_READ_SIZE 250000
1979 #define DURATION_MAX_RETRY 3
1981 /* only usable for MPEG-PS streams */
1982 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1984 AVPacket pkt1, *pkt = &pkt1;
1986 int read_size, i, ret;
1988 int64_t filesize, offset, duration;
1993 /* flush packet queue */
1994 flush_packet_queue(ic);
1996 for (i=0; i<ic->nb_streams; i++) {
1997 st = ic->streams[i];
1998 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1999 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2002 av_parser_close(st->parser);
2004 av_free_packet(&st->cur_pkt);
2008 /* estimate the end time (duration) */
2009 /* XXX: may need to support wrapping */
2010 filesize = ic->file_size;
2011 end_time = AV_NOPTS_VALUE;
2013 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2017 avio_seek(ic->pb, offset, SEEK_SET);
2020 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2024 ret = av_read_packet(ic, pkt);
2025 } while(ret == AVERROR(EAGAIN));
2028 read_size += pkt->size;
2029 st = ic->streams[pkt->stream_index];
2030 if (pkt->pts != AV_NOPTS_VALUE &&
2031 (st->start_time != AV_NOPTS_VALUE ||
2032 st->first_dts != AV_NOPTS_VALUE)) {
2033 duration = end_time = pkt->pts;
2034 if (st->start_time != AV_NOPTS_VALUE)
2035 duration -= st->start_time;
2037 duration -= st->first_dts;
2039 duration += 1LL<<st->pts_wrap_bits;
2041 if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
2042 st->duration = duration;
2045 av_free_packet(pkt);
2047 }while( end_time==AV_NOPTS_VALUE
2048 && filesize > (DURATION_MAX_READ_SIZE<<retry)
2049 && ++retry <= DURATION_MAX_RETRY);
2051 fill_all_stream_timings(ic);
2053 avio_seek(ic->pb, old_offset, SEEK_SET);
2054 for (i=0; i<ic->nb_streams; i++) {
2056 st->cur_dts= st->first_dts;
2057 st->last_IP_pts = AV_NOPTS_VALUE;
2058 st->reference_dts = AV_NOPTS_VALUE;
2062 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2066 /* get the file size, if possible */
2067 if (ic->iformat->flags & AVFMT_NOFILE) {
2070 file_size = avio_size(ic->pb);
2074 ic->file_size = file_size;
2076 if ((!strcmp(ic->iformat->name, "mpeg") ||
2077 !strcmp(ic->iformat->name, "mpegts")) &&
2078 file_size && ic->pb->seekable) {
2079 /* get accurate estimate from the PTSes */
2080 estimate_timings_from_pts(ic, old_offset);
2081 } else if (has_duration(ic)) {
2082 /* at least one component has timings - we use them for all
2084 fill_all_stream_timings(ic);
2086 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2087 /* less precise: use bitrate info */
2088 estimate_timings_from_bit_rate(ic);
2090 update_stream_timings(ic);
2094 AVStream av_unused *st;
2095 for(i = 0;i < ic->nb_streams; i++) {
2096 st = ic->streams[i];
2097 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2098 (double) st->start_time / AV_TIME_BASE,
2099 (double) st->duration / AV_TIME_BASE);
2101 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2102 (double) ic->start_time / AV_TIME_BASE,
2103 (double) ic->duration / AV_TIME_BASE,
2104 ic->bit_rate / 1000);
2108 static int has_codec_parameters(AVCodecContext *avctx)
2111 switch (avctx->codec_type) {
2112 case AVMEDIA_TYPE_AUDIO:
2113 val = avctx->sample_rate && avctx->channels && avctx->sample_fmt != AV_SAMPLE_FMT_NONE;
2114 if(!avctx->frame_size &&
2115 (avctx->codec_id == CODEC_ID_VORBIS ||
2116 avctx->codec_id == CODEC_ID_AAC ||
2117 avctx->codec_id == CODEC_ID_MP1 ||
2118 avctx->codec_id == CODEC_ID_MP2 ||
2119 avctx->codec_id == CODEC_ID_MP3 ||
2120 avctx->codec_id == CODEC_ID_SPEEX ||
2121 avctx->codec_id == CODEC_ID_CELT))
2124 case AVMEDIA_TYPE_VIDEO:
2125 val = avctx->width && avctx->pix_fmt != PIX_FMT_NONE;
2127 case AVMEDIA_TYPE_DATA:
2128 if(avctx->codec_id == CODEC_ID_NONE) return 1;
2133 return avctx->codec_id != CODEC_ID_NONE && val != 0;
2136 static int has_decode_delay_been_guessed(AVStream *st)
2138 return st->codec->codec_id != CODEC_ID_H264 ||
2139 st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2142 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2146 int got_picture, data_size, ret=0;
2149 if(!st->codec->codec){
2150 codec = avcodec_find_decoder(st->codec->codec_id);
2153 ret = avcodec_open2(st->codec, codec, options);
2158 if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st) ||
2159 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF)) {
2160 switch(st->codec->codec_type) {
2161 case AVMEDIA_TYPE_VIDEO:
2162 avcodec_get_frame_defaults(&picture);
2163 ret = avcodec_decode_video2(st->codec, &picture,
2164 &got_picture, avpkt);
2166 case AVMEDIA_TYPE_AUDIO:
2167 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2168 samples = av_malloc(data_size);
2171 ret = avcodec_decode_audio3(st->codec, samples,
2183 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2185 while (tags->id != CODEC_ID_NONE) {
2193 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2196 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2197 if(tag == tags[i].tag)
2200 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2201 if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2204 return CODEC_ID_NONE;
2207 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2210 for(i=0; tags && tags[i]; i++){
2211 int tag= ff_codec_get_tag(tags[i], id);
2217 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2220 for(i=0; tags && tags[i]; i++){
2221 enum CodecID id= ff_codec_get_id(tags[i], tag);
2222 if(id!=CODEC_ID_NONE) return id;
2224 return CODEC_ID_NONE;
2227 static void compute_chapters_end(AVFormatContext *s)
2230 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2232 for (i = 0; i < s->nb_chapters; i++)
2233 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2234 AVChapter *ch = s->chapters[i];
2235 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2238 for (j = 0; j < s->nb_chapters; j++) {
2239 AVChapter *ch1 = s->chapters[j];
2240 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2241 if (j != i && next_start > ch->start && next_start < end)
2244 ch->end = (end == INT64_MAX) ? ch->start : end;
2248 static int get_std_framerate(int i){
2249 if(i<60*12) return i*1001;
2250 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2254 * Is the time base unreliable.
2255 * This is a heuristic to balance between quick acceptance of the values in
2256 * the headers vs. some extra checks.
2257 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2258 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2259 * And there are "variable" fps files this needs to detect as well.
2261 static int tb_unreliable(AVCodecContext *c){
2262 if( c->time_base.den >= 101L*c->time_base.num
2263 || c->time_base.den < 5L*c->time_base.num
2264 /* || c->codec_tag == AV_RL32("DIVX")
2265 || c->codec_tag == AV_RL32("XVID")*/
2266 || c->codec_id == CODEC_ID_MPEG2VIDEO
2267 || c->codec_id == CODEC_ID_H264
2273 #if FF_API_FORMAT_PARAMETERS
2274 int av_find_stream_info(AVFormatContext *ic)
2276 return avformat_find_stream_info(ic, NULL);
2280 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2282 int i, count, ret, read_size, j;
2284 AVPacket pkt1, *pkt;
2285 int64_t old_offset = avio_tell(ic->pb);
2286 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2288 for(i=0;i<ic->nb_streams;i++) {
2290 st = ic->streams[i];
2291 if (st->codec->codec_id == CODEC_ID_AAC && st->codec->extradata_size) {
2292 // We need to discard these since they can be plain wrong for
2293 // backwards compatible HE-AAC signaling.
2294 // But when we have no extradata we need to keep them or we can't
2295 // play anything at all.
2296 st->codec->sample_rate = 0;
2297 st->codec->frame_size = 0;
2298 st->codec->channels = 0;
2301 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2302 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2303 /* if(!st->time_base.num)
2305 if(!st->codec->time_base.num)
2306 st->codec->time_base= st->time_base;
2308 //only for the split stuff
2309 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2310 st->parser = av_parser_init(st->codec->codec_id);
2311 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2312 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2315 assert(!st->codec->codec);
2316 codec = avcodec_find_decoder(st->codec->codec_id);
2318 /* Ensure that subtitle_header is properly set. */
2319 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2320 && codec && !st->codec->codec)
2321 avcodec_open2(st->codec, codec, options ? &options[i] : NULL);
2323 //try to just open decoders, in case this is enough to get parameters
2324 if(!has_codec_parameters(st->codec)){
2325 if (codec && !st->codec->codec){
2326 AVDictionary *tmp = NULL;
2328 av_dict_copy(&tmp, options[i], 0);
2329 av_dict_set(&tmp, "threads", 0, 0);
2331 avcodec_open2(st->codec, codec, options ? &tmp : NULL);
2337 for (i=0; i<ic->nb_streams; i++) {
2338 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2344 if(url_interrupt_cb()){
2346 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2350 /* check if one codec still needs to be handled */
2351 for(i=0;i<ic->nb_streams;i++) {
2352 int fps_analyze_framecount = 20;
2354 st = ic->streams[i];
2355 if (!has_codec_parameters(st->codec))
2357 /* if the timebase is coarse (like the usual millisecond precision
2358 of mkv), we need to analyze more frames to reliably arrive at
2360 if (av_q2d(st->time_base) > 0.0005)
2361 fps_analyze_framecount *= 2;
2362 if (ic->fps_probe_size >= 0)
2363 fps_analyze_framecount = ic->fps_probe_size;
2364 /* variable fps and no guess at the real fps */
2365 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2366 && st->info->duration_count < fps_analyze_framecount
2367 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2369 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2371 if(st->first_dts == AV_NOPTS_VALUE && (st->codec->codec_type == AVMEDIA_TYPE_VIDEO || st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2374 if (i == ic->nb_streams) {
2375 /* NOTE: if the format has no header, then we need to read
2376 some packets to get most of the streams, so we cannot
2378 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2379 /* if we found the info for all the codecs, we can stop */
2381 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2385 /* we did not get all the codec info, but we read too much data */
2386 if (read_size >= ic->probesize) {
2388 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2392 /* NOTE: a new stream can be added there if no header in file
2393 (AVFMTCTX_NOHEADER) */
2394 ret = read_frame_internal(ic, &pkt1);
2395 if (ret == AVERROR(EAGAIN))
2400 ret = -1; /* we could not have all the codec parameters before EOF */
2401 for(i=0;i<ic->nb_streams;i++) {
2402 st = ic->streams[i];
2403 if (!has_codec_parameters(st->codec)){
2405 avcodec_string(buf, sizeof(buf), st->codec, 0);
2406 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2414 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2415 if ((ret = av_dup_packet(pkt)) < 0)
2416 goto find_stream_info_err;
2418 read_size += pkt->size;
2420 st = ic->streams[pkt->stream_index];
2421 if (st->codec_info_nb_frames>1) {
2423 if (st->time_base.den > 0 && (t=av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q)) >= ic->max_analyze_duration) {
2424 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64"\n", ic->max_analyze_duration, t);
2427 st->info->codec_info_duration += pkt->duration;
2430 int64_t last = st->info->last_dts;
2431 int64_t duration= pkt->dts - last;
2433 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2434 double dts= pkt->dts * av_q2d(st->time_base);
2436 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2437 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2438 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); i++) {
2439 int framerate= get_std_framerate(i);
2440 double sdts= dts*framerate/(1001*12);
2442 int ticks= lrintf(sdts+j*0.5);
2443 double error= sdts - ticks + j*0.5;
2444 st->info->duration_error[j][0][i] += error;
2445 st->info->duration_error[j][1][i] += error*error;
2448 st->info->duration_count++;
2449 // ignore the first 4 values, they might have some random jitter
2450 if (st->info->duration_count > 3)
2451 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2453 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2454 st->info->last_dts = pkt->dts;
2456 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2457 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2459 st->codec->extradata_size= i;
2460 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2461 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2462 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2466 /* if still no information, we try to open the codec and to
2467 decompress the frame. We try to avoid that in most cases as
2468 it takes longer and uses more memory. For MPEG-4, we need to
2469 decompress for QuickTime.
2471 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2472 least one frame of codec data, this makes sure the codec initializes
2473 the channel configuration and does not only trust the values from the container.
2475 try_decode_frame(st, pkt, (options && i < orig_nb_streams )? &options[i] : NULL);
2477 st->codec_info_nb_frames++;
2481 // close codecs which were opened in try_decode_frame()
2482 for(i=0;i<ic->nb_streams;i++) {
2483 st = ic->streams[i];
2484 if(st->codec->codec)
2485 avcodec_close(st->codec);
2487 for(i=0;i<ic->nb_streams;i++) {
2488 st = ic->streams[i];
2489 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2490 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2491 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2492 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2493 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2494 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2495 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2496 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2497 st->codec->codec_tag= tag;
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 > FFMAX(1, st->time_base.den/(500LL*st->time_base.num)) && !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= 0.01;
2512 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); j++) {
2515 if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2518 int n= st->info->duration_count;
2519 double a= st->info->duration_error[k][0][j] / n;
2520 double error= st->info->duration_error[k][1][j]/n - a*a;
2522 if(error < best_error && best_error> 0.000000001){
2524 num = get_std_framerate(j);
2527 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2530 // do not increase frame rate by more than 1 % in order to match a standard rate.
2531 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2532 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2535 if (!st->r_frame_rate.num){
2536 if( st->codec->time_base.den * (int64_t)st->time_base.num
2537 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2538 st->r_frame_rate.num = st->codec->time_base.den;
2539 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2541 st->r_frame_rate.num = st->time_base.den;
2542 st->r_frame_rate.den = st->time_base.num;
2545 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2546 if(!st->codec->bits_per_coded_sample)
2547 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2548 // set stream disposition based on audio service type
2549 switch (st->codec->audio_service_type) {
2550 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2551 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2552 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2553 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2554 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2555 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2556 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2557 st->disposition = AV_DISPOSITION_COMMENT; break;
2558 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2559 st->disposition = AV_DISPOSITION_KARAOKE; break;
2564 estimate_timings(ic, old_offset);
2566 compute_chapters_end(ic);
2569 /* correct DTS for B-frame streams with no timestamps */
2570 for(i=0;i<ic->nb_streams;i++) {
2571 st = ic->streams[i];
2572 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2574 ppktl = &ic->packet_buffer;
2576 if(ppkt1->stream_index != i)
2578 if(ppkt1->pkt->dts < 0)
2580 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2582 ppkt1->pkt->dts -= delta;
2587 st->cur_dts -= delta;
2593 find_stream_info_err:
2594 for (i=0; i < ic->nb_streams; i++)
2595 av_freep(&ic->streams[i]->info);
2599 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
2603 for (i = 0; i < ic->nb_programs; i++) {
2604 if (ic->programs[i] == last) {
2608 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2609 if (ic->programs[i]->stream_index[j] == s)
2610 return ic->programs[i];
2616 int av_find_best_stream(AVFormatContext *ic,
2617 enum AVMediaType type,
2618 int wanted_stream_nb,
2620 AVCodec **decoder_ret,
2623 int i, nb_streams = ic->nb_streams;
2624 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2625 unsigned *program = NULL;
2626 AVCodec *decoder = NULL, *best_decoder = NULL;
2628 if (related_stream >= 0 && wanted_stream_nb < 0) {
2629 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
2631 program = p->stream_index;
2632 nb_streams = p->nb_stream_indexes;
2635 for (i = 0; i < nb_streams; i++) {
2636 int real_stream_index = program ? program[i] : i;
2637 AVStream *st = ic->streams[real_stream_index];
2638 AVCodecContext *avctx = st->codec;
2639 if (avctx->codec_type != type)
2641 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2643 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2646 decoder = avcodec_find_decoder(st->codec->codec_id);
2649 ret = AVERROR_DECODER_NOT_FOUND;
2653 if (best_count >= st->codec_info_nb_frames)
2655 best_count = st->codec_info_nb_frames;
2656 ret = real_stream_index;
2657 best_decoder = decoder;
2658 if (program && i == nb_streams - 1 && ret < 0) {
2660 nb_streams = ic->nb_streams;
2661 i = 0; /* no related stream found, try again with everything */
2665 *decoder_ret = best_decoder;
2669 /*******************************************************/
2671 int av_read_play(AVFormatContext *s)
2673 if (s->iformat->read_play)
2674 return s->iformat->read_play(s);
2676 return avio_pause(s->pb, 0);
2677 return AVERROR(ENOSYS);
2680 int av_read_pause(AVFormatContext *s)
2682 if (s->iformat->read_pause)
2683 return s->iformat->read_pause(s);
2685 return avio_pause(s->pb, 1);
2686 return AVERROR(ENOSYS);
2689 void av_close_input_stream(AVFormatContext *s)
2691 flush_packet_queue(s);
2692 if (s->iformat->read_close)
2693 s->iformat->read_close(s);
2694 avformat_free_context(s);
2697 void avformat_free_context(AVFormatContext *s)
2703 if (s->iformat && s->iformat->priv_class && s->priv_data)
2704 av_opt_free(s->priv_data);
2706 for(i=0;i<s->nb_streams;i++) {
2707 /* free all data in a stream component */
2710 av_parser_close(st->parser);
2711 av_free_packet(&st->cur_pkt);
2713 av_dict_free(&st->metadata);
2714 av_free(st->index_entries);
2715 av_free(st->codec->extradata);
2716 av_free(st->codec->subtitle_header);
2718 av_free(st->priv_data);
2722 for(i=s->nb_programs-1; i>=0; i--) {
2723 av_dict_free(&s->programs[i]->metadata);
2724 av_freep(&s->programs[i]->stream_index);
2725 av_freep(&s->programs[i]);
2727 av_freep(&s->programs);
2728 av_freep(&s->priv_data);
2729 while(s->nb_chapters--) {
2730 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2731 av_free(s->chapters[s->nb_chapters]);
2733 av_freep(&s->chapters);
2734 av_dict_free(&s->metadata);
2735 av_freep(&s->streams);
2739 void av_close_input_file(AVFormatContext *s)
2741 AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2743 av_close_input_stream(s);
2748 AVStream *av_new_stream(AVFormatContext *s, int id)
2754 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2756 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2759 s->streams = streams;
2761 st = av_mallocz(sizeof(AVStream));
2764 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2769 st->codec = avcodec_alloc_context3(NULL);
2771 /* no default bitrate if decoding */
2772 st->codec->bit_rate = 0;
2774 st->index = s->nb_streams;
2776 st->start_time = AV_NOPTS_VALUE;
2777 st->duration = AV_NOPTS_VALUE;
2778 /* we set the current DTS to 0 so that formats without any timestamps
2779 but durations get some timestamps, formats with some unknown
2780 timestamps have their first few packets buffered and the
2781 timestamps corrected before they are returned to the user */
2783 st->first_dts = AV_NOPTS_VALUE;
2784 st->probe_packets = MAX_PROBE_PACKETS;
2786 /* default pts setting is MPEG-like */
2787 av_set_pts_info(st, 33, 1, 90000);
2788 st->last_IP_pts = AV_NOPTS_VALUE;
2789 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2790 st->pts_buffer[i]= AV_NOPTS_VALUE;
2791 st->reference_dts = AV_NOPTS_VALUE;
2793 st->sample_aspect_ratio = (AVRational){0,1};
2795 s->streams[s->nb_streams++] = st;
2799 AVProgram *av_new_program(AVFormatContext *ac, int id)
2801 AVProgram *program=NULL;
2804 av_dlog(ac, "new_program: id=0x%04x\n", id);
2806 for(i=0; i<ac->nb_programs; i++)
2807 if(ac->programs[i]->id == id)
2808 program = ac->programs[i];
2811 program = av_mallocz(sizeof(AVProgram));
2814 dynarray_add(&ac->programs, &ac->nb_programs, program);
2815 program->discard = AVDISCARD_NONE;
2822 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2824 AVChapter *chapter = NULL;
2827 for(i=0; i<s->nb_chapters; i++)
2828 if(s->chapters[i]->id == id)
2829 chapter = s->chapters[i];
2832 chapter= av_mallocz(sizeof(AVChapter));
2835 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2837 av_dict_set(&chapter->metadata, "title", title, 0);
2839 chapter->time_base= time_base;
2840 chapter->start = start;
2846 /************************************************************/
2847 /* output media file */
2849 #if FF_API_FORMAT_PARAMETERS
2850 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2852 if (s->oformat->priv_data_size > 0) {
2853 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2855 return AVERROR(ENOMEM);
2856 if (s->oformat->priv_class) {
2857 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2858 av_opt_set_defaults(s->priv_data);
2861 s->priv_data = NULL;
2867 int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
2868 const char *format, const char *filename)
2870 AVFormatContext *s = avformat_alloc_context();
2879 oformat = av_guess_format(format, NULL, NULL);
2881 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
2882 ret = AVERROR(EINVAL);
2886 oformat = av_guess_format(NULL, filename, NULL);
2888 ret = AVERROR(EINVAL);
2889 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
2896 s->oformat = oformat;
2897 if (s->oformat->priv_data_size > 0) {
2898 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2901 if (s->oformat->priv_class) {
2902 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2903 av_opt_set_defaults(s->priv_data);
2906 s->priv_data = NULL;
2909 av_strlcpy(s->filename, filename, sizeof(s->filename));
2913 av_log(s, AV_LOG_ERROR, "Out of memory\n");
2914 ret = AVERROR(ENOMEM);
2916 avformat_free_context(s);
2920 #if FF_API_ALLOC_OUTPUT_CONTEXT
2921 AVFormatContext *avformat_alloc_output_context(const char *format,
2922 AVOutputFormat *oformat, const char *filename)
2924 AVFormatContext *avctx;
2925 int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
2926 return ret < 0 ? NULL : avctx;
2930 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2932 const AVCodecTag *avctag;
2934 enum CodecID id = CODEC_ID_NONE;
2935 unsigned int tag = 0;
2938 * Check that tag + id is in the table
2939 * If neither is in the table -> OK
2940 * If tag is in the table with another id -> FAIL
2941 * If id is in the table with another tag -> FAIL unless strict < normal
2943 for (n = 0; s->oformat->codec_tag[n]; n++) {
2944 avctag = s->oformat->codec_tag[n];
2945 while (avctag->id != CODEC_ID_NONE) {
2946 if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2948 if (id == st->codec->codec_id)
2951 if (avctag->id == st->codec->codec_id)
2956 if (id != CODEC_ID_NONE)
2958 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2963 #if FF_API_FORMAT_PARAMETERS
2964 int av_write_header(AVFormatContext *s)
2966 return avformat_write_header(s, NULL);
2970 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2974 AVDictionary *tmp = NULL;
2977 av_dict_copy(&tmp, *options, 0);
2978 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2980 if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
2981 (ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2984 // some sanity checks
2985 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2986 av_log(s, AV_LOG_ERROR, "no streams\n");
2987 ret = AVERROR(EINVAL);
2991 for(i=0;i<s->nb_streams;i++) {
2994 switch (st->codec->codec_type) {
2995 case AVMEDIA_TYPE_AUDIO:
2996 if(st->codec->sample_rate<=0){
2997 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2998 ret = AVERROR(EINVAL);
3001 if(!st->codec->block_align)
3002 st->codec->block_align = st->codec->channels *
3003 av_get_bits_per_sample(st->codec->codec_id) >> 3;
3005 case AVMEDIA_TYPE_VIDEO:
3006 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
3007 av_log(s, AV_LOG_ERROR, "time base not set\n");
3008 ret = AVERROR(EINVAL);
3011 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
3012 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
3013 ret = AVERROR(EINVAL);
3016 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
3017 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
3018 ret = AVERROR(EINVAL);
3024 if(s->oformat->codec_tag){
3025 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)){
3026 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
3027 st->codec->codec_tag= 0;
3029 if(st->codec->codec_tag){
3030 if (!validate_codec_tag(s, st)) {
3032 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
3033 av_log(s, AV_LOG_ERROR,
3034 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
3035 tagbuf, st->codec->codec_tag, st->codec->codec_id);
3036 ret = AVERROR_INVALIDDATA;
3040 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
3043 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
3044 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
3045 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
3048 if (!s->priv_data && s->oformat->priv_data_size > 0) {
3049 s->priv_data = av_mallocz(s->oformat->priv_data_size);
3050 if (!s->priv_data) {
3051 ret = AVERROR(ENOMEM);
3054 if (s->oformat->priv_class) {
3055 *(const AVClass**)s->priv_data= s->oformat->priv_class;
3056 av_opt_set_defaults(s->priv_data);
3057 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3062 /* set muxer identification string */
3063 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
3064 av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
3067 if(s->oformat->write_header){
3068 ret = s->oformat->write_header(s);
3073 /* init PTS generation */
3074 for(i=0;i<s->nb_streams;i++) {
3075 int64_t den = AV_NOPTS_VALUE;
3078 switch (st->codec->codec_type) {
3079 case AVMEDIA_TYPE_AUDIO:
3080 den = (int64_t)st->time_base.num * st->codec->sample_rate;
3082 case AVMEDIA_TYPE_VIDEO:
3083 den = (int64_t)st->time_base.num * st->codec->time_base.den;
3088 if (den != AV_NOPTS_VALUE) {
3090 ret = AVERROR_INVALIDDATA;
3093 frac_init(&st->pts, 0, 0, den);
3098 av_dict_free(options);
3107 //FIXME merge with compute_pkt_fields
3108 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3109 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3110 int num, den, frame_size, i;
3112 av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3113 pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3115 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
3116 return AVERROR(EINVAL);*/
3118 /* duration field */
3119 if (pkt->duration == 0) {
3120 compute_frame_duration(&num, &den, st, NULL, pkt);
3122 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3126 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3129 //XXX/FIXME this is a temporary hack until all encoders output pts
3130 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3132 // pkt->pts= st->cur_dts;
3133 pkt->pts= st->pts.val;
3136 //calculate dts from pts
3137 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3138 st->pts_buffer[0]= pkt->pts;
3139 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3140 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3141 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3142 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3144 pkt->dts= st->pts_buffer[0];
3147 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && ((!(s->oformat->flags & AVFMT_TS_NONSTRICT) && st->cur_dts >= pkt->dts) || st->cur_dts > pkt->dts)){
3148 av_log(s, AV_LOG_ERROR,
3149 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3150 st->index, st->cur_dts, pkt->dts);
3151 return AVERROR(EINVAL);
3153 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3154 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3155 return AVERROR(EINVAL);
3158 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3159 st->cur_dts= pkt->dts;
3160 st->pts.val= pkt->dts;
3163 switch (st->codec->codec_type) {
3164 case AVMEDIA_TYPE_AUDIO:
3165 frame_size = get_audio_frame_size(st->codec, pkt->size);
3167 /* HACK/FIXME, we skip the initial 0 size packets as they are most
3168 likely equal to the encoder delay, but it would be better if we
3169 had the real timestamps from the encoder */
3170 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3171 frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3174 case AVMEDIA_TYPE_VIDEO:
3175 frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3183 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3185 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3187 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3190 ret= s->oformat->write_packet(s, pkt);
3193 s->streams[pkt->stream_index]->nb_frames++;
3197 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3198 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3200 AVPacketList **next_point, *this_pktl;
3202 this_pktl = av_mallocz(sizeof(AVPacketList));
3203 this_pktl->pkt= *pkt;
3204 pkt->destruct= NULL; // do not free original but only the copy
3205 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
3207 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3208 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3210 next_point = &s->packet_buffer;
3213 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3214 while(!compare(s, &(*next_point)->pkt, pkt)){
3215 next_point= &(*next_point)->next;
3219 next_point = &(s->packet_buffer_end->next);
3222 assert(!*next_point);
3224 s->packet_buffer_end= this_pktl;
3227 this_pktl->next= *next_point;
3229 s->streams[pkt->stream_index]->last_in_packet_buffer=
3230 *next_point= this_pktl;
3233 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3235 AVStream *st = s->streams[ pkt ->stream_index];
3236 AVStream *st2= s->streams[ next->stream_index];
3237 int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3241 return pkt->stream_index < next->stream_index;
3245 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3247 int stream_count=0, noninterleaved_count=0;
3248 int64_t delta_dts_max = 0;
3252 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3255 for(i=0; i < s->nb_streams; i++) {
3256 if (s->streams[i]->last_in_packet_buffer) {
3258 } else if(s->streams[i]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3259 ++noninterleaved_count;
3263 if (s->nb_streams == stream_count) {
3266 for(i=0; i < s->nb_streams; i++) {
3267 if (s->streams[i]->last_in_packet_buffer) {
3269 av_rescale_q(s->streams[i]->last_in_packet_buffer->pkt.dts,
3270 s->streams[i]->time_base,
3272 av_rescale_q(s->packet_buffer->pkt.dts,
3273 s->streams[s->packet_buffer->pkt.stream_index]->time_base,
3275 delta_dts_max= FFMAX(delta_dts_max, delta_dts);
3278 if(s->nb_streams == stream_count+noninterleaved_count &&
3279 delta_dts_max > 20*AV_TIME_BASE) {
3280 av_log(s, AV_LOG_DEBUG, "flushing with %d noninterleaved\n", noninterleaved_count);
3284 if(stream_count && flush){
3285 pktl= s->packet_buffer;
3288 s->packet_buffer= pktl->next;
3289 if(!s->packet_buffer)
3290 s->packet_buffer_end= NULL;
3292 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3293 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3297 av_init_packet(out);
3303 * Interleave an AVPacket correctly so it can be muxed.
3304 * @param out the interleaved packet will be output here
3305 * @param in the input packet
3306 * @param flush 1 if no further packets are available as input and all
3307 * remaining packets should be output
3308 * @return 1 if a packet was output, 0 if no packet could be output,
3309 * < 0 if an error occurred
3311 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3312 if(s->oformat->interleave_packet)
3313 return s->oformat->interleave_packet(s, out, in, flush);
3315 return av_interleave_packet_per_dts(s, out, in, flush);
3318 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3319 AVStream *st= s->streams[ pkt->stream_index];
3322 //FIXME/XXX/HACK drop zero sized packets
3323 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3326 av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3327 pkt->size, pkt->dts, pkt->pts);
3328 if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3331 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3332 return AVERROR(EINVAL);
3336 int ret= interleave_packet(s, &opkt, pkt, 0);
3337 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3340 ret= s->oformat->write_packet(s, &opkt);
3342 s->streams[opkt.stream_index]->nb_frames++;
3344 av_free_packet(&opkt);
3349 if(url_ferror(s->pb))
3350 return url_ferror(s->pb);
3354 int av_write_trailer(AVFormatContext *s)
3360 ret= interleave_packet(s, &pkt, NULL, 1);
3361 if(ret<0) //FIXME cleanup needed for ret<0 ?
3366 ret= s->oformat->write_packet(s, &pkt);
3368 s->streams[pkt.stream_index]->nb_frames++;
3370 av_free_packet(&pkt);
3374 if(url_ferror(s->pb))
3378 if(s->oformat->write_trailer)
3379 ret = s->oformat->write_trailer(s);
3382 ret=url_ferror(s->pb);
3383 for(i=0;i<s->nb_streams;i++) {
3384 av_freep(&s->streams[i]->priv_data);
3385 av_freep(&s->streams[i]->index_entries);
3387 if (s->iformat && s->iformat->priv_class)
3388 av_opt_free(s->priv_data);
3389 av_freep(&s->priv_data);
3393 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
3394 int64_t *dts, int64_t *wall)
3396 if (!s->oformat || !s->oformat->get_output_timestamp)
3397 return AVERROR(ENOSYS);
3398 s->oformat->get_output_timestamp(s, stream, dts, wall);
3402 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3405 AVProgram *program=NULL;
3408 if (idx >= ac->nb_streams) {
3409 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3413 for(i=0; i<ac->nb_programs; i++){
3414 if(ac->programs[i]->id != progid)
3416 program = ac->programs[i];
3417 for(j=0; j<program->nb_stream_indexes; j++)
3418 if(program->stream_index[j] == idx)
3421 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3424 program->stream_index = tmp;
3425 program->stream_index[program->nb_stream_indexes++] = idx;
3430 static void print_fps(double d, const char *postfix){
3431 uint64_t v= lrintf(d*100);
3432 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3433 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3434 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3437 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3439 if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3440 AVDictionaryEntry *tag=NULL;
3442 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3443 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3444 if(strcmp("language", tag->key)){
3447 av_strlcpy(tmp, tag->value, sizeof(tmp));
3448 for(i=0; i<strlen(tmp); i++) if(tmp[i]==0xd) tmp[i]=' ';
3449 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tmp);
3455 /* "user interface" functions */
3456 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3459 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3460 AVStream *st = ic->streams[i];
3461 int g = av_gcd(st->time_base.num, st->time_base.den);
3462 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3463 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3464 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
3465 /* the pid is an important information, so we display it */
3466 /* XXX: add a generic system */
3467 if (flags & AVFMT_SHOW_IDS)
3468 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3470 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3471 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3472 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3473 if (st->sample_aspect_ratio.num && // default
3474 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3475 AVRational display_aspect_ratio;
3476 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3477 st->codec->width*st->sample_aspect_ratio.num,
3478 st->codec->height*st->sample_aspect_ratio.den,
3480 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3481 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3482 display_aspect_ratio.num, display_aspect_ratio.den);
3484 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3485 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3486 print_fps(av_q2d(st->avg_frame_rate), "fps");
3487 if(st->r_frame_rate.den && st->r_frame_rate.num)
3488 print_fps(av_q2d(st->r_frame_rate), "tbr");
3489 if(st->time_base.den && st->time_base.num)
3490 print_fps(1/av_q2d(st->time_base), "tbn");
3491 if(st->codec->time_base.den && st->codec->time_base.num)
3492 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3494 if (st->disposition & AV_DISPOSITION_DEFAULT)
3495 av_log(NULL, AV_LOG_INFO, " (default)");
3496 if (st->disposition & AV_DISPOSITION_DUB)
3497 av_log(NULL, AV_LOG_INFO, " (dub)");
3498 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3499 av_log(NULL, AV_LOG_INFO, " (original)");
3500 if (st->disposition & AV_DISPOSITION_COMMENT)
3501 av_log(NULL, AV_LOG_INFO, " (comment)");
3502 if (st->disposition & AV_DISPOSITION_LYRICS)
3503 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3504 if (st->disposition & AV_DISPOSITION_KARAOKE)
3505 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3506 if (st->disposition & AV_DISPOSITION_FORCED)
3507 av_log(NULL, AV_LOG_INFO, " (forced)");
3508 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3509 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3510 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3511 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3512 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3513 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3514 av_log(NULL, AV_LOG_INFO, "\n");
3515 dump_metadata(NULL, st->metadata, " ");
3518 #if FF_API_DUMP_FORMAT
3519 void dump_format(AVFormatContext *ic,
3524 av_dump_format(ic, index, url, is_output);
3528 void av_dump_format(AVFormatContext *ic,
3534 uint8_t *printed = av_mallocz(ic->nb_streams);
3535 if (ic->nb_streams && !printed)
3538 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3539 is_output ? "Output" : "Input",
3541 is_output ? ic->oformat->name : ic->iformat->name,
3542 is_output ? "to" : "from", url);
3543 dump_metadata(NULL, ic->metadata, " ");
3545 av_log(NULL, AV_LOG_INFO, " Duration: ");
3546 if (ic->duration != AV_NOPTS_VALUE) {
3547 int hours, mins, secs, us;
3548 secs = ic->duration / AV_TIME_BASE;
3549 us = ic->duration % AV_TIME_BASE;
3554 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3555 (100 * us) / AV_TIME_BASE);
3557 av_log(NULL, AV_LOG_INFO, "N/A");
3559 if (ic->start_time != AV_NOPTS_VALUE) {
3561 av_log(NULL, AV_LOG_INFO, ", start: ");
3562 secs = ic->start_time / AV_TIME_BASE;
3563 us = abs(ic->start_time % AV_TIME_BASE);
3564 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3565 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3567 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3569 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3571 av_log(NULL, AV_LOG_INFO, "N/A");
3573 av_log(NULL, AV_LOG_INFO, "\n");
3575 for (i = 0; i < ic->nb_chapters; i++) {
3576 AVChapter *ch = ic->chapters[i];
3577 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3578 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3579 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3581 dump_metadata(NULL, ch->metadata, " ");
3583 if(ic->nb_programs) {
3584 int j, k, total = 0;
3585 for(j=0; j<ic->nb_programs; j++) {
3586 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3588 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3589 name ? name->value : "");
3590 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3591 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3592 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3593 printed[ic->programs[j]->stream_index[k]] = 1;
3595 total += ic->programs[j]->nb_stream_indexes;
3597 if (total < ic->nb_streams)
3598 av_log(NULL, AV_LOG_INFO, " No Program\n");
3600 for(i=0;i<ic->nb_streams;i++)
3602 dump_stream_format(ic, i, index, is_output);
3607 int64_t av_gettime(void)
3610 gettimeofday(&tv,NULL);
3611 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3614 uint64_t ff_ntp_time(void)
3616 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3619 #if FF_API_PARSE_DATE
3620 #include "libavutil/parseutils.h"
3622 int64_t parse_date(const char *timestr, int duration)
3625 av_parse_time(&timeval, timestr, duration);
3630 #if FF_API_FIND_INFO_TAG
3631 #include "libavutil/parseutils.h"
3633 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3635 return av_find_info_tag(arg, arg_size, tag1, info);
3639 int av_get_frame_filename(char *buf, int buf_size,
3640 const char *path, int number)
3643 char *q, buf1[20], c;
3644 int nd, len, percentd_found;
3656 while (isdigit(*p)) {
3657 nd = nd * 10 + *p++ - '0';
3660 } while (isdigit(c));
3669 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3671 if ((q - buf + len) > buf_size - 1)
3673 memcpy(q, buf1, len);
3681 if ((q - buf) < buf_size - 1)
3685 if (!percentd_found)
3694 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3698 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3700 for(i=0;i<size;i+=16) {
3707 PRINT(" %02x", buf[i+j]);
3712 for(j=0;j<len;j++) {
3714 if (c < ' ' || c > '~')
3723 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3725 hex_dump_internal(NULL, f, 0, buf, size);
3728 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3730 hex_dump_internal(avcl, NULL, level, buf, size);
3733 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3736 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3737 PRINT("stream #%d:\n", pkt->stream_index);
3738 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3739 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3740 /* DTS is _always_ valid after av_read_frame() */
3742 if (pkt->dts == AV_NOPTS_VALUE)
3745 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3746 /* PTS may not be known if B-frames are present. */
3748 if (pkt->pts == AV_NOPTS_VALUE)
3751 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3753 PRINT(" size=%d\n", pkt->size);
3756 av_hex_dump(f, pkt->data, pkt->size);
3760 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3762 AVRational tb = { 1, AV_TIME_BASE };
3763 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3767 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3769 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3773 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3775 AVRational tb = { 1, AV_TIME_BASE };
3776 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3780 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3783 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3786 void av_url_split(char *proto, int proto_size,
3787 char *authorization, int authorization_size,
3788 char *hostname, int hostname_size,
3790 char *path, int path_size,
3793 const char *p, *ls, *at, *col, *brk;
3795 if (port_ptr) *port_ptr = -1;
3796 if (proto_size > 0) proto[0] = 0;
3797 if (authorization_size > 0) authorization[0] = 0;
3798 if (hostname_size > 0) hostname[0] = 0;
3799 if (path_size > 0) path[0] = 0;
3801 /* parse protocol */
3802 if ((p = strchr(url, ':'))) {
3803 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3808 /* no protocol means plain filename */
3809 av_strlcpy(path, url, path_size);
3813 /* separate path from hostname */
3814 ls = strchr(p, '/');
3816 ls = strchr(p, '?');
3818 av_strlcpy(path, ls, path_size);
3820 ls = &p[strlen(p)]; // XXX
3822 /* the rest is hostname, use that to parse auth/port */
3824 /* authorization (user[:pass]@hostname) */
3825 if ((at = strchr(p, '@')) && at < ls) {
3826 av_strlcpy(authorization, p,
3827 FFMIN(authorization_size, at + 1 - p));
3828 p = at + 1; /* skip '@' */
3831 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3833 av_strlcpy(hostname, p + 1,
3834 FFMIN(hostname_size, brk - p));
3835 if (brk[1] == ':' && port_ptr)
3836 *port_ptr = atoi(brk + 2);
3837 } else if ((col = strchr(p, ':')) && col < ls) {
3838 av_strlcpy(hostname, p,
3839 FFMIN(col + 1 - p, hostname_size));
3840 if (port_ptr) *port_ptr = atoi(col + 1);
3842 av_strlcpy(hostname, p,
3843 FFMIN(ls + 1 - p, hostname_size));
3847 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3850 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3853 'C', 'D', 'E', 'F' };
3854 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3857 'c', 'd', 'e', 'f' };
3858 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3860 for(i = 0; i < s; i++) {
3861 buff[i * 2] = hex_table[src[i] >> 4];
3862 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3868 int ff_hex_to_data(uint8_t *data, const char *p)
3875 p += strspn(p, SPACE_CHARS);
3878 c = toupper((unsigned char) *p++);
3879 if (c >= '0' && c <= '9')
3881 else if (c >= 'A' && c <= 'F')
3896 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3897 unsigned int pts_num, unsigned int pts_den)
3900 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3901 if(new_tb.num != pts_num)
3902 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3904 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3906 if(new_tb.num <= 0 || new_tb.den <= 0) {
3907 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3910 s->time_base = new_tb;
3911 s->pts_wrap_bits = pts_wrap_bits;
3914 int ff_url_join(char *str, int size, const char *proto,
3915 const char *authorization, const char *hostname,
3916 int port, const char *fmt, ...)
3919 struct addrinfo hints, *ai;
3924 av_strlcatf(str, size, "%s://", proto);
3925 if (authorization && authorization[0])
3926 av_strlcatf(str, size, "%s@", authorization);
3927 #if CONFIG_NETWORK && defined(AF_INET6)
3928 /* Determine if hostname is a numerical IPv6 address,
3929 * properly escape it within [] in that case. */
3930 memset(&hints, 0, sizeof(hints));
3931 hints.ai_flags = AI_NUMERICHOST;
3932 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3933 if (ai->ai_family == AF_INET6) {
3934 av_strlcat(str, "[", size);
3935 av_strlcat(str, hostname, size);
3936 av_strlcat(str, "]", size);
3938 av_strlcat(str, hostname, size);
3943 /* Not an IPv6 address, just output the plain string. */
3944 av_strlcat(str, hostname, size);
3947 av_strlcatf(str, size, ":%d", port);
3950 int len = strlen(str);
3953 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3959 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3960 AVFormatContext *src)
3965 local_pkt.stream_index = dst_stream;
3966 if (pkt->pts != AV_NOPTS_VALUE)
3967 local_pkt.pts = av_rescale_q(pkt->pts,
3968 src->streams[pkt->stream_index]->time_base,
3969 dst->streams[dst_stream]->time_base);
3970 if (pkt->dts != AV_NOPTS_VALUE)
3971 local_pkt.dts = av_rescale_q(pkt->dts,
3972 src->streams[pkt->stream_index]->time_base,
3973 dst->streams[dst_stream]->time_base);
3974 return av_write_frame(dst, &local_pkt);
3977 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3980 const char *ptr = str;
3982 /* Parse key=value pairs. */
3985 char *dest = NULL, *dest_end;
3986 int key_len, dest_len = 0;
3988 /* Skip whitespace and potential commas. */
3989 while (*ptr && (isspace(*ptr) || *ptr == ','))
3996 if (!(ptr = strchr(key, '=')))
3999 key_len = ptr - key;
4001 callback_get_buf(context, key, key_len, &dest, &dest_len);
4002 dest_end = dest + dest_len - 1;
4006 while (*ptr && *ptr != '\"') {
4010 if (dest && dest < dest_end)
4014 if (dest && dest < dest_end)
4022 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
4023 if (dest && dest < dest_end)
4031 int ff_find_stream_index(AVFormatContext *s, int id)
4034 for (i = 0; i < s->nb_streams; i++) {
4035 if (s->streams[i]->id == id)
4041 void ff_make_absolute_url(char *buf, int size, const char *base,
4045 /* Absolute path, relative to the current server */
4046 if (base && strstr(base, "://") && rel[0] == '/') {
4048 av_strlcpy(buf, base, size);
4049 sep = strstr(buf, "://");
4052 sep = strchr(sep, '/');
4056 av_strlcat(buf, rel, size);
4059 /* If rel actually is an absolute url, just copy it */
4060 if (!base || strstr(rel, "://") || rel[0] == '/') {
4061 av_strlcpy(buf, rel, size);
4065 av_strlcpy(buf, base, size);
4066 /* Remove the file name from the base url */
4067 sep = strrchr(buf, '/');
4072 while (av_strstart(rel, "../", NULL) && sep) {
4073 /* Remove the path delimiter at the end */
4075 sep = strrchr(buf, '/');
4076 /* If the next directory name to pop off is "..", break here */
4077 if (!strcmp(sep ? &sep[1] : buf, "..")) {
4078 /* Readd the slash we just removed */
4079 av_strlcat(buf, "/", size);
4082 /* Cut off the directory name */
4089 av_strlcat(buf, rel, size);
4092 int64_t ff_iso8601_to_unix_time(const char *datestr)
4095 struct tm time = {0};
4096 strptime(datestr, "%Y - %m - %dT%T", &time);
4097 return mktime(&time);
4099 av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
4100 "the date string.\n");
4105 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
4108 if (ofmt->query_codec)
4109 return ofmt->query_codec(codec_id, std_compliance);
4110 else if (ofmt->codec_tag)
4111 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4112 else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4113 codec_id == ofmt->subtitle_codec)
4116 return AVERROR_PATCHWELCOME;