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 AV_NOWARN_DEPRECATED(
409 if (ap->time_base.num) {
410 snprintf(buf, sizeof(buf), "%d/%d", ap->time_base.den, ap->time_base.num);
411 av_dict_set(&opts, "framerate", buf, 0);
413 if (ap->sample_rate) {
414 snprintf(buf, sizeof(buf), "%d", ap->sample_rate);
415 av_dict_set(&opts, "sample_rate", buf, 0);
418 snprintf(buf, sizeof(buf), "%d", ap->channels);
419 av_dict_set(&opts, "channels", buf, 0);
421 if (ap->width || ap->height) {
422 snprintf(buf, sizeof(buf), "%dx%d", ap->width, ap->height);
423 av_dict_set(&opts, "video_size", buf, 0);
425 if (ap->pix_fmt != PIX_FMT_NONE) {
426 av_dict_set(&opts, "pixel_format", av_get_pix_fmt_name(ap->pix_fmt), 0);
429 snprintf(buf, sizeof(buf), "%d", ap->channel);
430 av_dict_set(&opts, "channel", buf, 0);
433 av_dict_set(&opts, "standard", ap->standard, 0);
435 if (ap->mpeg2ts_compute_pcr) {
436 av_dict_set(&opts, "mpeg2ts_compute_pcr", "1", 0);
438 if (ap->initial_pause) {
439 av_dict_set(&opts, "initial_pause", "1", 0);
446 * Open a media file from an IO stream. 'fmt' must be specified.
448 int av_open_input_stream(AVFormatContext **ic_ptr,
449 AVIOContext *pb, const char *filename,
450 AVInputFormat *fmt, AVFormatParameters *ap)
455 AVFormatParameters default_ap;
459 memset(ap, 0, sizeof(default_ap));
461 opts = convert_format_parameters(ap);
463 AV_NOWARN_DEPRECATED(
464 if(!ap->prealloced_context)
465 *ic_ptr = ic = avformat_alloc_context();
470 err = AVERROR(ENOMEM);
473 if (pb && fmt && fmt->flags & AVFMT_NOFILE)
474 av_log(ic, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
475 "will be ignored with AVFMT_NOFILE format.\n");
479 if ((err = avformat_open_input(&ic, filename, fmt, &opts)) < 0)
481 ic->pb = ic->pb ? ic->pb : pb; // don't leak custom pb if it wasn't set above
490 int av_demuxer_open(AVFormatContext *ic, AVFormatParameters *ap){
493 if (ic->iformat->read_header) {
494 err = ic->iformat->read_header(ic, ap);
499 if (ic->pb && !ic->data_offset)
500 ic->data_offset = avio_tell(ic->pb);
506 /** size of probe buffer, for guessing file type from file contents */
507 #define PROBE_BUF_MIN 2048
508 #define PROBE_BUF_MAX (1<<20)
510 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
511 const char *filename, void *logctx,
512 unsigned int offset, unsigned int max_probe_size)
514 AVProbeData pd = { filename ? filename : "", NULL, -offset };
515 unsigned char *buf = NULL;
516 int ret = 0, probe_size;
518 if (!max_probe_size) {
519 max_probe_size = PROBE_BUF_MAX;
520 } else if (max_probe_size > PROBE_BUF_MAX) {
521 max_probe_size = PROBE_BUF_MAX;
522 } else if (max_probe_size < PROBE_BUF_MIN) {
523 return AVERROR(EINVAL);
526 if (offset >= max_probe_size) {
527 return AVERROR(EINVAL);
530 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
531 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
532 int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
533 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
536 if (probe_size < offset) {
540 /* read probe data */
541 buftmp = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
544 return AVERROR(ENOMEM);
547 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
548 /* fail if error was not end of file, otherwise, lower score */
549 if (ret != AVERROR_EOF) {
554 ret = 0; /* error was end of file, nothing read */
557 pd.buf = &buf[offset];
559 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
561 /* guess file format */
562 *fmt = av_probe_input_format2(&pd, 1, &score);
564 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
565 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
567 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
573 return AVERROR_INVALIDDATA;
576 /* rewind. reuse probe buffer to avoid seeking */
577 if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
583 #if FF_API_FORMAT_PARAMETERS
584 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
587 AVFormatParameters *ap)
590 AVDictionary *opts = convert_format_parameters(ap);
592 AV_NOWARN_DEPRECATED(
593 if (!ap || !ap->prealloced_context)
597 err = avformat_open_input(ic_ptr, filename, fmt, &opts);
604 /* open input file and probe the format if necessary */
605 static int init_input(AVFormatContext *s, const char *filename)
608 AVProbeData pd = {filename, NULL, 0};
611 s->flags |= AVFMT_FLAG_CUSTOM_IO;
613 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
614 else if (s->iformat->flags & AVFMT_NOFILE)
615 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
616 "will be ignored with AVFMT_NOFILE format.\n");
620 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
621 (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
624 if ((ret = avio_open(&s->pb, filename, AVIO_FLAG_READ)) < 0)
628 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
631 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
633 AVFormatContext *s = *ps;
635 AVFormatParameters ap = { { 0 } };
636 AVDictionary *tmp = NULL;
638 if (!s && !(s = avformat_alloc_context()))
639 return AVERROR(ENOMEM);
644 av_dict_copy(&tmp, *options, 0);
646 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
649 if ((ret = init_input(s, filename)) < 0)
652 /* check filename in case an image number is expected */
653 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
654 if (!av_filename_number_test(filename)) {
655 ret = AVERROR(EINVAL);
660 s->duration = s->start_time = AV_NOPTS_VALUE;
661 av_strlcpy(s->filename, filename, sizeof(s->filename));
663 /* allocate private data */
664 if (s->iformat->priv_data_size > 0) {
665 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
666 ret = AVERROR(ENOMEM);
669 if (s->iformat->priv_class) {
670 *(const AVClass**)s->priv_data = s->iformat->priv_class;
671 av_opt_set_defaults(s->priv_data);
672 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
677 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
679 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC);
681 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
682 if ((ret = s->iformat->read_header(s, &ap)) < 0)
685 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
686 s->data_offset = avio_tell(s->pb);
688 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
691 av_dict_free(options);
699 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
701 avformat_free_context(s);
706 /*******************************************************/
708 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
709 AVPacketList **plast_pktl){
710 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
715 (*plast_pktl)->next = pktl;
717 *packet_buffer = pktl;
719 /* add the packet in the buffered packet list */
725 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
731 AVPacketList *pktl = s->raw_packet_buffer;
735 if(s->streams[pkt->stream_index]->request_probe <= 0){
736 s->raw_packet_buffer = pktl->next;
737 s->raw_packet_buffer_remaining_size += pkt->size;
744 ret= s->iformat->read_packet(s, pkt);
746 if (!pktl || ret == AVERROR(EAGAIN))
748 for (i = 0; i < s->nb_streams; i++)
749 if(s->streams[i]->request_probe > 0)
750 s->streams[i]->request_probe = -1;
754 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
755 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
756 av_log(s, AV_LOG_WARNING,
757 "Dropped corrupted packet (stream = %d)\n",
762 if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
763 av_packet_merge_side_data(pkt);
765 st= s->streams[pkt->stream_index];
767 switch(st->codec->codec_type){
768 case AVMEDIA_TYPE_VIDEO:
769 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
771 case AVMEDIA_TYPE_AUDIO:
772 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
774 case AVMEDIA_TYPE_SUBTITLE:
775 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
779 if(!pktl && st->request_probe <= 0)
782 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
783 s->raw_packet_buffer_remaining_size -= pkt->size;
785 if(st->request_probe>0){
786 AVProbeData *pd = &st->probe_data;
788 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
791 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
792 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
793 pd->buf_size += pkt->size;
794 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
796 end= s->raw_packet_buffer_remaining_size <= 0
797 || st->probe_packets<=0;
799 if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
800 int score= set_codec_from_probe_data(s, st, pd);
801 if( (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
805 st->request_probe= -1;
806 if(st->codec->codec_id != CODEC_ID_NONE){
807 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
809 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
816 /**********************************************************/
819 * Get the number of samples of an audio frame. Return -1 on error.
821 static int get_audio_frame_size(AVCodecContext *enc, int size)
825 if(enc->codec_id == CODEC_ID_VORBIS)
828 if (enc->frame_size <= 1) {
829 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
831 if (bits_per_sample) {
832 if (enc->channels == 0)
834 frame_size = (size << 3) / (bits_per_sample * enc->channels);
836 /* used for example by ADPCM codecs */
837 if (enc->bit_rate == 0)
839 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
842 frame_size = enc->frame_size;
849 * Return the frame duration in seconds. Return 0 if not available.
851 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
852 AVCodecParserContext *pc, AVPacket *pkt)
858 switch(st->codec->codec_type) {
859 case AVMEDIA_TYPE_VIDEO:
860 if(st->time_base.num*1000LL > st->time_base.den){
861 *pnum = st->time_base.num;
862 *pden = st->time_base.den;
863 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
864 *pnum = st->codec->time_base.num;
865 *pden = st->codec->time_base.den;
866 if (pc && pc->repeat_pict) {
867 *pnum = (*pnum) * (1 + pc->repeat_pict);
869 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
870 //Thus if we have no parser in such case leave duration undefined.
871 if(st->codec->ticks_per_frame>1 && !pc){
876 case AVMEDIA_TYPE_AUDIO:
877 frame_size = get_audio_frame_size(st->codec, pkt->size);
878 if (frame_size <= 0 || st->codec->sample_rate <= 0)
881 *pden = st->codec->sample_rate;
888 static int is_intra_only(AVCodecContext *enc){
889 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
891 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
892 switch(enc->codec_id){
894 case CODEC_ID_MJPEGB:
896 case CODEC_ID_PRORES:
897 case CODEC_ID_RAWVIDEO:
898 case CODEC_ID_DVVIDEO:
899 case CODEC_ID_HUFFYUV:
900 case CODEC_ID_FFVHUFF:
905 case CODEC_ID_JPEG2000:
913 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
914 int64_t dts, int64_t pts)
916 AVStream *st= s->streams[stream_index];
917 AVPacketList *pktl= s->packet_buffer;
919 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
922 st->first_dts= dts - st->cur_dts;
925 for(; pktl; pktl= pktl->next){
926 if(pktl->pkt.stream_index != stream_index)
928 //FIXME think more about this check
929 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
930 pktl->pkt.pts += st->first_dts;
932 if(pktl->pkt.dts != AV_NOPTS_VALUE)
933 pktl->pkt.dts += st->first_dts;
935 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
936 st->start_time= pktl->pkt.pts;
938 if (st->start_time == AV_NOPTS_VALUE)
939 st->start_time = pts;
942 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
944 AVPacketList *pktl= s->packet_buffer;
947 if(st->first_dts != AV_NOPTS_VALUE){
948 cur_dts= st->first_dts;
949 for(; pktl; pktl= pktl->next){
950 if(pktl->pkt.stream_index == pkt->stream_index){
951 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
953 cur_dts -= pkt->duration;
956 pktl= s->packet_buffer;
957 st->first_dts = cur_dts;
958 }else if(st->cur_dts)
961 for(; pktl; pktl= pktl->next){
962 if(pktl->pkt.stream_index != pkt->stream_index)
964 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
965 && !pktl->pkt.duration){
966 pktl->pkt.dts= cur_dts;
967 if(!st->codec->has_b_frames)
968 pktl->pkt.pts= cur_dts;
969 cur_dts += pkt->duration;
970 pktl->pkt.duration= pkt->duration;
974 if(st->first_dts == AV_NOPTS_VALUE)
975 st->cur_dts= cur_dts;
978 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
979 AVCodecParserContext *pc, AVPacket *pkt)
981 int num, den, presentation_delayed, delay, i;
984 if (s->flags & AVFMT_FLAG_NOFILLIN)
987 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
988 pkt->dts= AV_NOPTS_VALUE;
990 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
991 //FIXME Set low_delay = 0 when has_b_frames = 1
992 st->codec->has_b_frames = 1;
994 /* do we have a video B-frame ? */
995 delay= st->codec->has_b_frames;
996 presentation_delayed = 0;
998 // ignore delay caused by frame threading so that the mpeg2-without-dts
999 // warning will not trigger
1000 if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
1001 delay -= st->codec->thread_count-1;
1003 /* XXX: need has_b_frame, but cannot get it if the codec is
1006 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1007 presentation_delayed = 1;
1009 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > pkt->pts && st->pts_wrap_bits<63){
1010 pkt->dts -= 1LL<<st->pts_wrap_bits;
1013 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
1014 // we take the conservative approach and discard both
1015 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
1016 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
1017 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1018 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
1021 if (pkt->duration == 0) {
1022 compute_frame_duration(&num, &den, st, pc, pkt);
1024 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1026 if(pkt->duration != 0 && s->packet_buffer)
1027 update_initial_durations(s, st, pkt);
1031 /* correct timestamps with byte offset if demuxers only have timestamps
1032 on packet boundaries */
1033 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1034 /* this will estimate bitrate based on this frame's duration and size */
1035 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1036 if(pkt->pts != AV_NOPTS_VALUE)
1038 if(pkt->dts != AV_NOPTS_VALUE)
1042 if (pc && pc->dts_sync_point >= 0) {
1043 // we have synchronization info from the parser
1044 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1046 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1047 if (pkt->dts != AV_NOPTS_VALUE) {
1048 // got DTS from the stream, update reference timestamp
1049 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1050 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1051 } else if (st->reference_dts != AV_NOPTS_VALUE) {
1052 // compute DTS based on reference timestamp
1053 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1054 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1056 if (pc->dts_sync_point > 0)
1057 st->reference_dts = pkt->dts; // new reference
1061 /* This may be redundant, but it should not hurt. */
1062 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1063 presentation_delayed = 1;
1065 // 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);
1066 /* interpolate PTS and DTS if they are not present */
1067 //We skip H264 currently because delay and has_b_frames are not reliably set
1068 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1069 if (presentation_delayed) {
1070 /* DTS = decompression timestamp */
1071 /* PTS = presentation timestamp */
1072 if (pkt->dts == AV_NOPTS_VALUE)
1073 pkt->dts = st->last_IP_pts;
1074 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1075 if (pkt->dts == AV_NOPTS_VALUE)
1076 pkt->dts = st->cur_dts;
1078 /* this is tricky: the dts must be incremented by the duration
1079 of the frame we are displaying, i.e. the last I- or P-frame */
1080 if (st->last_IP_duration == 0)
1081 st->last_IP_duration = pkt->duration;
1082 if(pkt->dts != AV_NOPTS_VALUE)
1083 st->cur_dts = pkt->dts + st->last_IP_duration;
1084 st->last_IP_duration = pkt->duration;
1085 st->last_IP_pts= pkt->pts;
1086 /* cannot compute PTS if not present (we can compute it only
1087 by knowing the future */
1088 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1089 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1090 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1091 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1092 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1093 pkt->pts += pkt->duration;
1094 // 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);
1098 /* presentation is not delayed : PTS and DTS are the same */
1099 if(pkt->pts == AV_NOPTS_VALUE)
1100 pkt->pts = pkt->dts;
1101 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1102 if(pkt->pts == AV_NOPTS_VALUE)
1103 pkt->pts = st->cur_dts;
1104 pkt->dts = pkt->pts;
1105 if(pkt->pts != AV_NOPTS_VALUE)
1106 st->cur_dts = pkt->pts + pkt->duration;
1110 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1111 st->pts_buffer[0]= pkt->pts;
1112 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1113 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1114 if(pkt->dts == AV_NOPTS_VALUE)
1115 pkt->dts= st->pts_buffer[0];
1116 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1117 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1119 if(pkt->dts > st->cur_dts)
1120 st->cur_dts = pkt->dts;
1123 // 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);
1126 if(is_intra_only(st->codec))
1127 pkt->flags |= AV_PKT_FLAG_KEY;
1130 /* keyframe computation */
1131 if (pc->key_frame == 1)
1132 pkt->flags |= AV_PKT_FLAG_KEY;
1133 else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
1134 pkt->flags |= AV_PKT_FLAG_KEY;
1137 pkt->convergence_duration = pc->convergence_duration;
1141 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1146 av_init_packet(pkt);
1149 /* select current input stream component */
1152 if (!st->need_parsing || !st->parser) {
1153 /* no parsing needed: we just output the packet as is */
1154 /* raw data support */
1156 st->cur_pkt.data= NULL;
1157 st->cur_pkt.side_data_elems = 0;
1158 st->cur_pkt.side_data = NULL;
1159 compute_pkt_fields(s, st, NULL, pkt);
1161 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1162 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1163 ff_reduce_index(s, st->index);
1164 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1167 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1168 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1169 st->cur_ptr, st->cur_len,
1170 st->cur_pkt.pts, st->cur_pkt.dts,
1172 st->cur_pkt.pts = AV_NOPTS_VALUE;
1173 st->cur_pkt.dts = AV_NOPTS_VALUE;
1174 /* increment read pointer */
1178 /* return packet if any */
1182 pkt->stream_index = st->index;
1183 pkt->pts = st->parser->pts;
1184 pkt->dts = st->parser->dts;
1185 pkt->pos = st->parser->pos;
1186 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1188 pkt->destruct= st->cur_pkt.destruct;
1189 st->cur_pkt.destruct= NULL;
1190 st->cur_pkt.data = NULL;
1191 assert(st->cur_len == 0);
1193 pkt->destruct = NULL;
1195 compute_pkt_fields(s, st, st->parser, pkt);
1197 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1198 int64_t pos= (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->pos : st->parser->frame_offset;
1199 ff_reduce_index(s, st->index);
1200 av_add_index_entry(st, pos, pkt->dts,
1201 0, 0, AVINDEX_KEYFRAME);
1208 av_free_packet(&st->cur_pkt);
1213 /* read next packet */
1214 ret = av_read_packet(s, &cur_pkt);
1216 if (ret == AVERROR(EAGAIN))
1218 /* return the last frames, if any */
1219 for(i = 0; i < s->nb_streams; i++) {
1221 if (st->parser && st->need_parsing) {
1222 av_parser_parse2(st->parser, st->codec,
1223 &pkt->data, &pkt->size,
1225 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1231 /* no more packets: really terminate parsing */
1234 st = s->streams[cur_pkt.stream_index];
1235 st->cur_pkt= cur_pkt;
1237 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1238 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1239 st->cur_pkt.pts < st->cur_pkt.dts){
1240 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1241 st->cur_pkt.stream_index,
1245 // av_free_packet(&st->cur_pkt);
1249 if(s->debug & FF_FDEBUG_TS)
1250 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1251 st->cur_pkt.stream_index,
1255 st->cur_pkt.duration,
1259 st->cur_ptr = st->cur_pkt.data;
1260 st->cur_len = st->cur_pkt.size;
1261 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1262 st->parser = av_parser_init(st->codec->codec_id);
1264 av_log(s, AV_LOG_WARNING, "parser not found for codec "
1265 "%s, packets or times may be invalid.\n",
1266 avcodec_get_name(st->codec->codec_id));
1267 /* no parser available: just output the raw packets */
1268 st->need_parsing = AVSTREAM_PARSE_NONE;
1269 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1270 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1271 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1272 st->parser->flags |= PARSER_FLAG_ONCE;
1277 if(s->debug & FF_FDEBUG_TS)
1278 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1289 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1293 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1296 pktl = s->packet_buffer;
1298 AVPacket *next_pkt= &pktl->pkt;
1300 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1301 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1302 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1303 if( pktl->pkt.stream_index == next_pkt->stream_index
1304 && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1305 && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1306 next_pkt->pts= pktl->pkt.dts;
1310 pktl = s->packet_buffer;
1313 if( next_pkt->pts != AV_NOPTS_VALUE
1314 || next_pkt->dts == AV_NOPTS_VALUE
1316 /* read packet from packet buffer, if there is data */
1318 s->packet_buffer = pktl->next;
1324 int ret= read_frame_internal(s, pkt);
1326 if(pktl && ret != AVERROR(EAGAIN)){
1333 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1334 &s->packet_buffer_end)) < 0)
1335 return AVERROR(ENOMEM);
1337 assert(!s->packet_buffer);
1338 return read_frame_internal(s, pkt);
1343 /* XXX: suppress the packet queue */
1344 static void flush_packet_queue(AVFormatContext *s)
1349 pktl = s->packet_buffer;
1352 s->packet_buffer = pktl->next;
1353 av_free_packet(&pktl->pkt);
1356 while(s->raw_packet_buffer){
1357 pktl = s->raw_packet_buffer;
1358 s->raw_packet_buffer = pktl->next;
1359 av_free_packet(&pktl->pkt);
1362 s->packet_buffer_end=
1363 s->raw_packet_buffer_end= NULL;
1364 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1367 /*******************************************************/
1370 int av_find_default_stream_index(AVFormatContext *s)
1372 int first_audio_index = -1;
1376 if (s->nb_streams <= 0)
1378 for(i = 0; i < s->nb_streams; i++) {
1380 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1383 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1384 first_audio_index = i;
1386 return first_audio_index >= 0 ? first_audio_index : 0;
1390 * Flush the frame reader.
1392 void ff_read_frame_flush(AVFormatContext *s)
1397 flush_packet_queue(s);
1401 /* for each stream, reset read state */
1402 for(i = 0; i < s->nb_streams; i++) {
1406 av_parser_close(st->parser);
1408 av_free_packet(&st->cur_pkt);
1410 st->last_IP_pts = AV_NOPTS_VALUE;
1411 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1412 st->reference_dts = AV_NOPTS_VALUE;
1417 st->probe_packets = MAX_PROBE_PACKETS;
1419 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1420 st->pts_buffer[j]= AV_NOPTS_VALUE;
1424 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1427 for(i = 0; i < s->nb_streams; i++) {
1428 AVStream *st = s->streams[i];
1430 st->cur_dts = av_rescale(timestamp,
1431 st->time_base.den * (int64_t)ref_st->time_base.num,
1432 st->time_base.num * (int64_t)ref_st->time_base.den);
1436 void ff_reduce_index(AVFormatContext *s, int stream_index)
1438 AVStream *st= s->streams[stream_index];
1439 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1441 if((unsigned)st->nb_index_entries >= max_entries){
1443 for(i=0; 2*i<st->nb_index_entries; i++)
1444 st->index_entries[i]= st->index_entries[2*i];
1445 st->nb_index_entries= i;
1449 int ff_add_index_entry(AVIndexEntry **index_entries,
1450 int *nb_index_entries,
1451 unsigned int *index_entries_allocated_size,
1452 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1454 AVIndexEntry *entries, *ie;
1457 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1460 entries = av_fast_realloc(*index_entries,
1461 index_entries_allocated_size,
1462 (*nb_index_entries + 1) *
1463 sizeof(AVIndexEntry));
1467 *index_entries= entries;
1469 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1472 index= (*nb_index_entries)++;
1473 ie= &entries[index];
1474 assert(index==0 || ie[-1].timestamp < timestamp);
1476 ie= &entries[index];
1477 if(ie->timestamp != timestamp){
1478 if(ie->timestamp <= timestamp)
1480 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1481 (*nb_index_entries)++;
1482 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1483 distance= ie->min_distance;
1487 ie->timestamp = timestamp;
1488 ie->min_distance= distance;
1495 int av_add_index_entry(AVStream *st,
1496 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1498 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1499 &st->index_entries_allocated_size, pos,
1500 timestamp, size, distance, flags);
1503 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1504 int64_t wanted_timestamp, int flags)
1512 //optimize appending index entries at the end
1513 if(b && entries[b-1].timestamp < wanted_timestamp)
1518 timestamp = entries[m].timestamp;
1519 if(timestamp >= wanted_timestamp)
1521 if(timestamp <= wanted_timestamp)
1524 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1526 if(!(flags & AVSEEK_FLAG_ANY)){
1527 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1528 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1537 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1540 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1541 wanted_timestamp, flags);
1544 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1545 AVInputFormat *avif= s->iformat;
1546 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1547 int64_t ts_min, ts_max, ts;
1552 if (stream_index < 0)
1555 av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1558 ts_min= AV_NOPTS_VALUE;
1559 pos_limit= -1; //gcc falsely says it may be uninitialized
1561 st= s->streams[stream_index];
1562 if(st->index_entries){
1565 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()
1566 index= FFMAX(index, 0);
1567 e= &st->index_entries[index];
1569 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1571 ts_min= e->timestamp;
1572 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1578 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1579 assert(index < st->nb_index_entries);
1581 e= &st->index_entries[index];
1582 assert(e->timestamp >= target_ts);
1584 ts_max= e->timestamp;
1585 pos_limit= pos_max - e->min_distance;
1586 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1587 pos_max,pos_limit, ts_max);
1591 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1596 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1599 av_update_cur_dts(s, st, ts);
1604 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 )){
1606 int64_t start_pos, filesize;
1609 av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1611 if(ts_min == AV_NOPTS_VALUE){
1612 pos_min = s->data_offset;
1613 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1614 if (ts_min == AV_NOPTS_VALUE)
1618 if(ts_max == AV_NOPTS_VALUE){
1620 filesize = avio_size(s->pb);
1621 pos_max = filesize - 1;
1624 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1626 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1627 if (ts_max == AV_NOPTS_VALUE)
1631 int64_t tmp_pos= pos_max + 1;
1632 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1633 if(tmp_ts == AV_NOPTS_VALUE)
1637 if(tmp_pos >= filesize)
1643 if(ts_min > ts_max){
1645 }else if(ts_min == ts_max){
1650 while (pos_min < pos_limit) {
1651 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1652 pos_min, pos_max, ts_min, ts_max);
1653 assert(pos_limit <= pos_max);
1656 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1657 // interpolate position (better than dichotomy)
1658 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1659 + pos_min - approximate_keyframe_distance;
1660 }else if(no_change==1){
1661 // bisection, if interpolation failed to change min or max pos last time
1662 pos = (pos_min + pos_limit)>>1;
1664 /* linear search if bisection failed, can only happen if there
1665 are very few or no keyframes between min/max */
1670 else if(pos > pos_limit)
1674 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1679 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1680 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1681 pos_limit, start_pos, no_change);
1682 if(ts == AV_NOPTS_VALUE){
1683 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1686 assert(ts != AV_NOPTS_VALUE);
1687 if (target_ts <= ts) {
1688 pos_limit = start_pos - 1;
1692 if (target_ts >= ts) {
1698 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1699 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1701 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1703 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1704 av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1705 pos, ts_min, target_ts, ts_max);
1710 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1711 int64_t pos_min, pos_max;
1715 if (stream_index < 0)
1718 st= s->streams[stream_index];
1721 pos_min = s->data_offset;
1722 pos_max = avio_size(s->pb) - 1;
1724 if (pos < pos_min) pos= pos_min;
1725 else if(pos > pos_max) pos= pos_max;
1727 avio_seek(s->pb, pos, SEEK_SET);
1730 av_update_cur_dts(s, st, ts);
1735 static int seek_frame_generic(AVFormatContext *s,
1736 int stream_index, int64_t timestamp, int flags)
1743 st = s->streams[stream_index];
1745 index = av_index_search_timestamp(st, timestamp, flags);
1747 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1750 if(index < 0 || index==st->nb_index_entries-1){
1754 if(st->nb_index_entries){
1755 assert(st->index_entries);
1756 ie= &st->index_entries[st->nb_index_entries-1];
1757 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1759 av_update_cur_dts(s, st, ie->timestamp);
1761 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1767 read_status = av_read_frame(s, &pkt);
1768 } while (read_status == AVERROR(EAGAIN));
1769 if (read_status < 0)
1771 av_free_packet(&pkt);
1772 if(stream_index == pkt.stream_index && pkt.dts > timestamp){
1773 if(pkt.flags & AV_PKT_FLAG_KEY)
1775 if(nonkey++ > 1000){
1776 av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
1781 index = av_index_search_timestamp(st, timestamp, flags);
1786 ff_read_frame_flush(s);
1787 AV_NOWARN_DEPRECATED(
1788 if (s->iformat->read_seek){
1789 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1793 ie = &st->index_entries[index];
1794 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1796 av_update_cur_dts(s, st, ie->timestamp);
1801 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1806 ff_read_frame_flush(s);
1808 if(flags & AVSEEK_FLAG_BYTE)
1809 return seek_frame_byte(s, stream_index, timestamp, flags);
1811 if(stream_index < 0){
1812 stream_index= av_find_default_stream_index(s);
1813 if(stream_index < 0)
1816 st= s->streams[stream_index];
1817 /* timestamp for default must be expressed in AV_TIME_BASE units */
1818 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1821 /* first, we try the format specific seek */
1822 AV_NOWARN_DEPRECATED(
1823 if (s->iformat->read_seek)
1824 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1832 if(s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH))
1833 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1834 else if (!(s->iformat->flags & AVFMT_NOGENSEARCH))
1835 return seek_frame_generic(s, stream_index, timestamp, flags);
1840 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1842 if(min_ts > ts || max_ts < ts)
1845 ff_read_frame_flush(s);
1847 if (s->iformat->read_seek2)
1848 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1850 if(s->iformat->read_timestamp){
1851 //try to seek via read_timestamp()
1854 //Fallback to old API if new is not implemented but old is
1855 //Note the old has somewat different sematics
1856 AV_NOWARN_DEPRECATED(
1857 if(s->iformat->read_seek || 1)
1858 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1861 // try some generic seek like seek_frame_generic() but with new ts semantics
1864 /*******************************************************/
1867 * Return TRUE if the stream has accurate duration in any stream.
1869 * @return TRUE if the stream has accurate duration for at least one component.
1871 static int has_duration(AVFormatContext *ic)
1875 if(ic->duration != AV_NOPTS_VALUE)
1878 for(i = 0;i < ic->nb_streams; i++) {
1879 st = ic->streams[i];
1880 if (st->duration != AV_NOPTS_VALUE)
1887 * Estimate the stream timings from the one of each components.
1889 * Also computes the global bitrate if possible.
1891 static void update_stream_timings(AVFormatContext *ic)
1893 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
1894 int64_t duration, duration1;
1898 start_time = INT64_MAX;
1899 start_time_text = INT64_MAX;
1900 end_time = INT64_MIN;
1901 duration = INT64_MIN;
1902 for(i = 0;i < ic->nb_streams; i++) {
1903 st = ic->streams[i];
1904 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1905 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1906 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1907 if (start_time1 < start_time_text)
1908 start_time_text = start_time1;
1910 if (start_time1 < start_time)
1911 start_time = start_time1;
1912 if (st->duration != AV_NOPTS_VALUE) {
1913 end_time1 = start_time1
1914 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1915 if (end_time1 > end_time)
1916 end_time = end_time1;
1919 if (st->duration != AV_NOPTS_VALUE) {
1920 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1921 if (duration1 > duration)
1922 duration = duration1;
1925 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
1926 start_time = start_time_text;
1927 if (start_time != INT64_MAX) {
1928 ic->start_time = start_time;
1929 if (end_time != INT64_MIN) {
1930 if (end_time - start_time > duration)
1931 duration = end_time - start_time;
1934 if (duration != INT64_MIN && ic->duration == AV_NOPTS_VALUE) {
1935 ic->duration = duration;
1937 if (ic->file_size > 0 && ic->duration != AV_NOPTS_VALUE) {
1938 /* compute the bitrate */
1939 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1940 (double)ic->duration;
1944 static void fill_all_stream_timings(AVFormatContext *ic)
1949 update_stream_timings(ic);
1950 for(i = 0;i < ic->nb_streams; i++) {
1951 st = ic->streams[i];
1952 if (st->start_time == AV_NOPTS_VALUE) {
1953 if(ic->start_time != AV_NOPTS_VALUE)
1954 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1955 if(ic->duration != AV_NOPTS_VALUE)
1956 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1961 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1963 int64_t filesize, duration;
1967 /* if bit_rate is already set, we believe it */
1968 if (ic->bit_rate <= 0) {
1970 for(i=0;i<ic->nb_streams;i++) {
1971 st = ic->streams[i];
1972 if (st->codec->bit_rate > 0)
1973 bit_rate += st->codec->bit_rate;
1975 ic->bit_rate = bit_rate;
1978 /* if duration is already set, we believe it */
1979 if (ic->duration == AV_NOPTS_VALUE &&
1980 ic->bit_rate != 0 &&
1981 ic->file_size != 0) {
1982 filesize = ic->file_size;
1984 for(i = 0; i < ic->nb_streams; i++) {
1985 st = ic->streams[i];
1986 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1987 if (st->duration == AV_NOPTS_VALUE)
1988 st->duration = duration;
1994 #define DURATION_MAX_READ_SIZE 250000
1995 #define DURATION_MAX_RETRY 3
1997 /* only usable for MPEG-PS streams */
1998 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2000 AVPacket pkt1, *pkt = &pkt1;
2002 int read_size, i, ret;
2004 int64_t filesize, offset, duration;
2009 /* flush packet queue */
2010 flush_packet_queue(ic);
2012 for (i=0; i<ic->nb_streams; i++) {
2013 st = ic->streams[i];
2014 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2015 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2018 av_parser_close(st->parser);
2020 av_free_packet(&st->cur_pkt);
2024 /* estimate the end time (duration) */
2025 /* XXX: may need to support wrapping */
2026 filesize = ic->file_size;
2027 end_time = AV_NOPTS_VALUE;
2029 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2033 avio_seek(ic->pb, offset, SEEK_SET);
2036 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2040 ret = av_read_packet(ic, pkt);
2041 } while(ret == AVERROR(EAGAIN));
2044 read_size += pkt->size;
2045 st = ic->streams[pkt->stream_index];
2046 if (pkt->pts != AV_NOPTS_VALUE &&
2047 (st->start_time != AV_NOPTS_VALUE ||
2048 st->first_dts != AV_NOPTS_VALUE)) {
2049 duration = end_time = pkt->pts;
2050 if (st->start_time != AV_NOPTS_VALUE)
2051 duration -= st->start_time;
2053 duration -= st->first_dts;
2055 duration += 1LL<<st->pts_wrap_bits;
2057 if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
2058 st->duration = duration;
2061 av_free_packet(pkt);
2063 }while( end_time==AV_NOPTS_VALUE
2064 && filesize > (DURATION_MAX_READ_SIZE<<retry)
2065 && ++retry <= DURATION_MAX_RETRY);
2067 fill_all_stream_timings(ic);
2069 avio_seek(ic->pb, old_offset, SEEK_SET);
2070 for (i=0; i<ic->nb_streams; i++) {
2072 st->cur_dts= st->first_dts;
2073 st->last_IP_pts = AV_NOPTS_VALUE;
2074 st->reference_dts = AV_NOPTS_VALUE;
2078 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2082 /* get the file size, if possible */
2083 if (ic->iformat->flags & AVFMT_NOFILE) {
2086 file_size = avio_size(ic->pb);
2090 ic->file_size = file_size;
2092 if ((!strcmp(ic->iformat->name, "mpeg") ||
2093 !strcmp(ic->iformat->name, "mpegts")) &&
2094 file_size && ic->pb->seekable) {
2095 /* get accurate estimate from the PTSes */
2096 estimate_timings_from_pts(ic, old_offset);
2097 } else if (has_duration(ic)) {
2098 /* at least one component has timings - we use them for all
2100 fill_all_stream_timings(ic);
2102 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2103 /* less precise: use bitrate info */
2104 estimate_timings_from_bit_rate(ic);
2106 update_stream_timings(ic);
2110 AVStream av_unused *st;
2111 for(i = 0;i < ic->nb_streams; i++) {
2112 st = ic->streams[i];
2113 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2114 (double) st->start_time / AV_TIME_BASE,
2115 (double) st->duration / AV_TIME_BASE);
2117 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2118 (double) ic->start_time / AV_TIME_BASE,
2119 (double) ic->duration / AV_TIME_BASE,
2120 ic->bit_rate / 1000);
2124 static int has_codec_parameters(AVCodecContext *avctx)
2127 switch (avctx->codec_type) {
2128 case AVMEDIA_TYPE_AUDIO:
2129 val = avctx->sample_rate && avctx->channels && avctx->sample_fmt != AV_SAMPLE_FMT_NONE;
2130 if (!avctx->frame_size &&
2131 (avctx->codec_id == CODEC_ID_VORBIS ||
2132 avctx->codec_id == CODEC_ID_AAC ||
2133 avctx->codec_id == CODEC_ID_MP1 ||
2134 avctx->codec_id == CODEC_ID_MP2 ||
2135 avctx->codec_id == CODEC_ID_MP3 ||
2136 avctx->codec_id == CODEC_ID_SPEEX ||
2137 avctx->codec_id == CODEC_ID_CELT))
2140 case AVMEDIA_TYPE_VIDEO:
2141 val = avctx->width && avctx->pix_fmt != PIX_FMT_NONE;
2143 case AVMEDIA_TYPE_DATA:
2144 if(avctx->codec_id == CODEC_ID_NONE) return 1;
2149 return avctx->codec_id != CODEC_ID_NONE && val != 0;
2152 static int has_decode_delay_been_guessed(AVStream *st)
2154 return st->codec->codec_id != CODEC_ID_H264 ||
2155 st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2158 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2162 int got_picture, data_size, ret=0;
2165 if(!st->codec->codec){
2166 codec = avcodec_find_decoder(st->codec->codec_id);
2169 ret = avcodec_open2(st->codec, codec, options);
2174 if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st) ||
2175 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF)) {
2176 switch(st->codec->codec_type) {
2177 case AVMEDIA_TYPE_VIDEO:
2178 avcodec_get_frame_defaults(&picture);
2179 ret = avcodec_decode_video2(st->codec, &picture,
2180 &got_picture, avpkt);
2182 case AVMEDIA_TYPE_AUDIO:
2183 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2184 samples = av_malloc(data_size);
2187 ret = avcodec_decode_audio3(st->codec, samples,
2199 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2201 while (tags->id != CODEC_ID_NONE) {
2209 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2212 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2213 if(tag == tags[i].tag)
2216 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2217 if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2220 return CODEC_ID_NONE;
2223 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2226 for(i=0; tags && tags[i]; i++){
2227 int tag= ff_codec_get_tag(tags[i], id);
2233 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2236 for(i=0; tags && tags[i]; i++){
2237 enum CodecID id= ff_codec_get_id(tags[i], tag);
2238 if(id!=CODEC_ID_NONE) return id;
2240 return CODEC_ID_NONE;
2243 static void compute_chapters_end(AVFormatContext *s)
2246 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2248 for (i = 0; i < s->nb_chapters; i++)
2249 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2250 AVChapter *ch = s->chapters[i];
2251 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2254 for (j = 0; j < s->nb_chapters; j++) {
2255 AVChapter *ch1 = s->chapters[j];
2256 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2257 if (j != i && next_start > ch->start && next_start < end)
2260 ch->end = (end == INT64_MAX) ? ch->start : end;
2264 static int get_std_framerate(int i){
2265 if(i<60*12) return i*1001;
2266 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2270 * Is the time base unreliable.
2271 * This is a heuristic to balance between quick acceptance of the values in
2272 * the headers vs. some extra checks.
2273 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2274 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2275 * And there are "variable" fps files this needs to detect as well.
2277 static int tb_unreliable(AVCodecContext *c){
2278 if( c->time_base.den >= 101L*c->time_base.num
2279 || c->time_base.den < 5L*c->time_base.num
2280 /* || c->codec_tag == AV_RL32("DIVX")
2281 || c->codec_tag == AV_RL32("XVID")*/
2282 || c->codec_id == CODEC_ID_MPEG2VIDEO
2283 || c->codec_id == CODEC_ID_H264
2289 #if FF_API_FORMAT_PARAMETERS
2290 int av_find_stream_info(AVFormatContext *ic)
2292 return avformat_find_stream_info(ic, NULL);
2296 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2298 int i, count, ret, read_size, j;
2300 AVPacket pkt1, *pkt;
2301 int64_t old_offset = avio_tell(ic->pb);
2302 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2304 for(i=0;i<ic->nb_streams;i++) {
2306 st = ic->streams[i];
2308 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2309 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2310 /* if(!st->time_base.num)
2312 if(!st->codec->time_base.num)
2313 st->codec->time_base= st->time_base;
2315 //only for the split stuff
2316 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2317 st->parser = av_parser_init(st->codec->codec_id);
2318 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2319 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2322 assert(!st->codec->codec);
2323 codec = avcodec_find_decoder(st->codec->codec_id);
2325 /* Ensure that subtitle_header is properly set. */
2326 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2327 && codec && !st->codec->codec)
2328 avcodec_open2(st->codec, codec, options ? &options[i] : NULL);
2330 //try to just open decoders, in case this is enough to get parameters
2331 if(!has_codec_parameters(st->codec)){
2332 if (codec && !st->codec->codec){
2333 AVDictionary *tmp = NULL;
2335 av_dict_copy(&tmp, options[i], 0);
2336 av_dict_set(&tmp, "threads", 0, 0);
2338 avcodec_open2(st->codec, codec, options ? &tmp : NULL);
2344 for (i=0; i<ic->nb_streams; i++) {
2345 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2351 if(url_interrupt_cb()){
2353 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2357 /* check if one codec still needs to be handled */
2358 for(i=0;i<ic->nb_streams;i++) {
2359 int fps_analyze_framecount = 20;
2361 st = ic->streams[i];
2362 if (!has_codec_parameters(st->codec))
2364 /* if the timebase is coarse (like the usual millisecond precision
2365 of mkv), we need to analyze more frames to reliably arrive at
2367 if (av_q2d(st->time_base) > 0.0005)
2368 fps_analyze_framecount *= 2;
2369 if (ic->fps_probe_size >= 0)
2370 fps_analyze_framecount = ic->fps_probe_size;
2371 /* variable fps and no guess at the real fps */
2372 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2373 && st->info->duration_count < fps_analyze_framecount
2374 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2376 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2378 if(st->first_dts == AV_NOPTS_VALUE && (st->codec->codec_type == AVMEDIA_TYPE_VIDEO || st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2381 if (i == ic->nb_streams) {
2382 /* NOTE: if the format has no header, then we need to read
2383 some packets to get most of the streams, so we cannot
2385 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2386 /* if we found the info for all the codecs, we can stop */
2388 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2392 /* we did not get all the codec info, but we read too much data */
2393 if (read_size >= ic->probesize) {
2395 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2399 /* NOTE: a new stream can be added there if no header in file
2400 (AVFMTCTX_NOHEADER) */
2401 ret = read_frame_internal(ic, &pkt1);
2402 if (ret == AVERROR(EAGAIN))
2407 ret = -1; /* we could not have all the codec parameters before EOF */
2408 for(i=0;i<ic->nb_streams;i++) {
2409 st = ic->streams[i];
2410 if (!has_codec_parameters(st->codec)){
2412 avcodec_string(buf, sizeof(buf), st->codec, 0);
2413 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2421 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2422 if ((ret = av_dup_packet(pkt)) < 0)
2423 goto find_stream_info_err;
2425 read_size += pkt->size;
2427 st = ic->streams[pkt->stream_index];
2428 if (st->codec_info_nb_frames>1) {
2430 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) {
2431 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64"\n", ic->max_analyze_duration, t);
2434 st->info->codec_info_duration += pkt->duration;
2437 int64_t last = st->info->last_dts;
2438 int64_t duration= pkt->dts - last;
2440 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2441 double dts= pkt->dts * av_q2d(st->time_base);
2443 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2444 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2445 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); i++) {
2446 int framerate= get_std_framerate(i);
2447 double sdts= dts*framerate/(1001*12);
2449 int ticks= lrintf(sdts+j*0.5);
2450 double error= sdts - ticks + j*0.5;
2451 st->info->duration_error[j][0][i] += error;
2452 st->info->duration_error[j][1][i] += error*error;
2455 st->info->duration_count++;
2456 // ignore the first 4 values, they might have some random jitter
2457 if (st->info->duration_count > 3)
2458 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2460 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2461 st->info->last_dts = pkt->dts;
2463 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2464 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2466 st->codec->extradata_size= i;
2467 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2468 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2469 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2473 /* if still no information, we try to open the codec and to
2474 decompress the frame. We try to avoid that in most cases as
2475 it takes longer and uses more memory. For MPEG-4, we need to
2476 decompress for QuickTime.
2478 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2479 least one frame of codec data, this makes sure the codec initializes
2480 the channel configuration and does not only trust the values from the container.
2482 try_decode_frame(st, pkt, (options && i < orig_nb_streams )? &options[i] : NULL);
2484 st->codec_info_nb_frames++;
2488 // close codecs which were opened in try_decode_frame()
2489 for(i=0;i<ic->nb_streams;i++) {
2490 st = ic->streams[i];
2491 if(st->codec->codec)
2492 avcodec_close(st->codec);
2494 for(i=0;i<ic->nb_streams;i++) {
2495 st = ic->streams[i];
2496 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2497 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2498 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2499 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2500 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2501 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2502 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2503 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2504 st->codec->codec_tag= tag;
2507 // the check for tb_unreliable() is not completely correct, since this is not about handling
2508 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2509 // ipmovie.c produces.
2510 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)
2511 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);
2512 if (st->info->duration_count && !st->r_frame_rate.num
2513 && tb_unreliable(st->codec) /*&&
2514 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2515 st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2517 double best_error= 0.01;
2519 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); j++) {
2522 if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2525 int n= st->info->duration_count;
2526 double a= st->info->duration_error[k][0][j] / n;
2527 double error= st->info->duration_error[k][1][j]/n - a*a;
2529 if(error < best_error && best_error> 0.000000001){
2531 num = get_std_framerate(j);
2534 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2537 // do not increase frame rate by more than 1 % in order to match a standard rate.
2538 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2539 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2542 if (!st->r_frame_rate.num){
2543 if( st->codec->time_base.den * (int64_t)st->time_base.num
2544 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2545 st->r_frame_rate.num = st->codec->time_base.den;
2546 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2548 st->r_frame_rate.num = st->time_base.den;
2549 st->r_frame_rate.den = st->time_base.num;
2552 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2553 if(!st->codec->bits_per_coded_sample)
2554 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2555 // set stream disposition based on audio service type
2556 switch (st->codec->audio_service_type) {
2557 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2558 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2559 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2560 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2561 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2562 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2563 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2564 st->disposition = AV_DISPOSITION_COMMENT; break;
2565 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2566 st->disposition = AV_DISPOSITION_KARAOKE; break;
2571 estimate_timings(ic, old_offset);
2573 compute_chapters_end(ic);
2576 /* correct DTS for B-frame streams with no timestamps */
2577 for(i=0;i<ic->nb_streams;i++) {
2578 st = ic->streams[i];
2579 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2581 ppktl = &ic->packet_buffer;
2583 if(ppkt1->stream_index != i)
2585 if(ppkt1->pkt->dts < 0)
2587 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2589 ppkt1->pkt->dts -= delta;
2594 st->cur_dts -= delta;
2600 find_stream_info_err:
2601 for (i=0; i < ic->nb_streams; i++)
2602 av_freep(&ic->streams[i]->info);
2606 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
2610 for (i = 0; i < ic->nb_programs; i++) {
2611 if (ic->programs[i] == last) {
2615 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2616 if (ic->programs[i]->stream_index[j] == s)
2617 return ic->programs[i];
2623 int av_find_best_stream(AVFormatContext *ic,
2624 enum AVMediaType type,
2625 int wanted_stream_nb,
2627 AVCodec **decoder_ret,
2630 int i, nb_streams = ic->nb_streams;
2631 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2632 unsigned *program = NULL;
2633 AVCodec *decoder = NULL, *best_decoder = NULL;
2635 if (related_stream >= 0 && wanted_stream_nb < 0) {
2636 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
2638 program = p->stream_index;
2639 nb_streams = p->nb_stream_indexes;
2642 for (i = 0; i < nb_streams; i++) {
2643 int real_stream_index = program ? program[i] : i;
2644 AVStream *st = ic->streams[real_stream_index];
2645 AVCodecContext *avctx = st->codec;
2646 if (avctx->codec_type != type)
2648 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2650 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2653 decoder = avcodec_find_decoder(st->codec->codec_id);
2656 ret = AVERROR_DECODER_NOT_FOUND;
2660 if (best_count >= st->codec_info_nb_frames)
2662 best_count = st->codec_info_nb_frames;
2663 ret = real_stream_index;
2664 best_decoder = decoder;
2665 if (program && i == nb_streams - 1 && ret < 0) {
2667 nb_streams = ic->nb_streams;
2668 i = 0; /* no related stream found, try again with everything */
2672 *decoder_ret = best_decoder;
2676 /*******************************************************/
2678 int av_read_play(AVFormatContext *s)
2680 if (s->iformat->read_play)
2681 return s->iformat->read_play(s);
2683 return avio_pause(s->pb, 0);
2684 return AVERROR(ENOSYS);
2687 int av_read_pause(AVFormatContext *s)
2689 if (s->iformat->read_pause)
2690 return s->iformat->read_pause(s);
2692 return avio_pause(s->pb, 1);
2693 return AVERROR(ENOSYS);
2696 void av_close_input_stream(AVFormatContext *s)
2698 flush_packet_queue(s);
2699 if (s->iformat->read_close)
2700 s->iformat->read_close(s);
2701 avformat_free_context(s);
2704 void avformat_free_context(AVFormatContext *s)
2710 if (s->iformat && s->iformat->priv_class && s->priv_data)
2711 av_opt_free(s->priv_data);
2713 for(i=0;i<s->nb_streams;i++) {
2714 /* free all data in a stream component */
2717 av_parser_close(st->parser);
2718 av_free_packet(&st->cur_pkt);
2720 av_dict_free(&st->metadata);
2721 av_freep(&st->index_entries);
2722 av_freep(&st->codec->extradata);
2723 av_freep(&st->codec->subtitle_header);
2724 av_freep(&st->codec);
2725 av_freep(&st->priv_data);
2726 av_freep(&st->info);
2729 for(i=s->nb_programs-1; i>=0; i--) {
2730 av_dict_free(&s->programs[i]->metadata);
2731 av_freep(&s->programs[i]->stream_index);
2732 av_freep(&s->programs[i]);
2734 av_freep(&s->programs);
2735 av_freep(&s->priv_data);
2736 while(s->nb_chapters--) {
2737 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2738 av_freep(&s->chapters[s->nb_chapters]);
2740 av_freep(&s->chapters);
2741 av_dict_free(&s->metadata);
2742 av_freep(&s->streams);
2746 void av_close_input_file(AVFormatContext *s)
2748 AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2750 av_close_input_stream(s);
2755 AVStream *av_new_stream(AVFormatContext *s, int id)
2761 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2763 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2766 s->streams = streams;
2768 st = av_mallocz(sizeof(AVStream));
2771 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2776 st->codec = avcodec_alloc_context3(NULL);
2778 /* no default bitrate if decoding */
2779 st->codec->bit_rate = 0;
2781 st->index = s->nb_streams;
2783 st->start_time = AV_NOPTS_VALUE;
2784 st->duration = AV_NOPTS_VALUE;
2785 /* we set the current DTS to 0 so that formats without any timestamps
2786 but durations get some timestamps, formats with some unknown
2787 timestamps have their first few packets buffered and the
2788 timestamps corrected before they are returned to the user */
2790 st->first_dts = AV_NOPTS_VALUE;
2791 st->probe_packets = MAX_PROBE_PACKETS;
2793 /* default pts setting is MPEG-like */
2794 av_set_pts_info(st, 33, 1, 90000);
2795 st->last_IP_pts = AV_NOPTS_VALUE;
2796 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2797 st->pts_buffer[i]= AV_NOPTS_VALUE;
2798 st->reference_dts = AV_NOPTS_VALUE;
2800 st->sample_aspect_ratio = (AVRational){0,1};
2802 s->streams[s->nb_streams++] = st;
2806 AVProgram *av_new_program(AVFormatContext *ac, int id)
2808 AVProgram *program=NULL;
2811 av_dlog(ac, "new_program: id=0x%04x\n", id);
2813 for(i=0; i<ac->nb_programs; i++)
2814 if(ac->programs[i]->id == id)
2815 program = ac->programs[i];
2818 program = av_mallocz(sizeof(AVProgram));
2821 dynarray_add(&ac->programs, &ac->nb_programs, program);
2822 program->discard = AVDISCARD_NONE;
2829 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2831 AVChapter *chapter = NULL;
2834 for(i=0; i<s->nb_chapters; i++)
2835 if(s->chapters[i]->id == id)
2836 chapter = s->chapters[i];
2839 chapter= av_mallocz(sizeof(AVChapter));
2842 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2844 av_dict_set(&chapter->metadata, "title", title, 0);
2846 chapter->time_base= time_base;
2847 chapter->start = start;
2853 /************************************************************/
2854 /* output media file */
2856 #if FF_API_FORMAT_PARAMETERS
2857 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2859 if (s->oformat->priv_data_size > 0) {
2860 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2862 return AVERROR(ENOMEM);
2863 if (s->oformat->priv_class) {
2864 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2865 av_opt_set_defaults(s->priv_data);
2868 s->priv_data = NULL;
2874 int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
2875 const char *format, const char *filename)
2877 AVFormatContext *s = avformat_alloc_context();
2886 oformat = av_guess_format(format, NULL, NULL);
2888 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
2889 ret = AVERROR(EINVAL);
2893 oformat = av_guess_format(NULL, filename, NULL);
2895 ret = AVERROR(EINVAL);
2896 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
2903 s->oformat = oformat;
2904 if (s->oformat->priv_data_size > 0) {
2905 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2908 if (s->oformat->priv_class) {
2909 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2910 av_opt_set_defaults(s->priv_data);
2913 s->priv_data = NULL;
2916 av_strlcpy(s->filename, filename, sizeof(s->filename));
2920 av_log(s, AV_LOG_ERROR, "Out of memory\n");
2921 ret = AVERROR(ENOMEM);
2923 avformat_free_context(s);
2927 #if FF_API_ALLOC_OUTPUT_CONTEXT
2928 AVFormatContext *avformat_alloc_output_context(const char *format,
2929 AVOutputFormat *oformat, const char *filename)
2931 AVFormatContext *avctx;
2932 int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
2933 return ret < 0 ? NULL : avctx;
2937 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2939 const AVCodecTag *avctag;
2941 enum CodecID id = CODEC_ID_NONE;
2942 unsigned int tag = 0;
2945 * Check that tag + id is in the table
2946 * If neither is in the table -> OK
2947 * If tag is in the table with another id -> FAIL
2948 * If id is in the table with another tag -> FAIL unless strict < normal
2950 for (n = 0; s->oformat->codec_tag[n]; n++) {
2951 avctag = s->oformat->codec_tag[n];
2952 while (avctag->id != CODEC_ID_NONE) {
2953 if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2955 if (id == st->codec->codec_id)
2958 if (avctag->id == st->codec->codec_id)
2963 if (id != CODEC_ID_NONE)
2965 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2970 #if FF_API_FORMAT_PARAMETERS
2971 int av_write_header(AVFormatContext *s)
2973 return avformat_write_header(s, NULL);
2977 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2981 AVDictionary *tmp = NULL;
2984 av_dict_copy(&tmp, *options, 0);
2985 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2987 if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
2988 (ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2991 // some sanity checks
2992 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2993 av_log(s, AV_LOG_ERROR, "no streams\n");
2994 ret = AVERROR(EINVAL);
2998 for(i=0;i<s->nb_streams;i++) {
3001 switch (st->codec->codec_type) {
3002 case AVMEDIA_TYPE_AUDIO:
3003 if(st->codec->sample_rate<=0){
3004 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
3005 ret = AVERROR(EINVAL);
3008 if(!st->codec->block_align)
3009 st->codec->block_align = st->codec->channels *
3010 av_get_bits_per_sample(st->codec->codec_id) >> 3;
3012 case AVMEDIA_TYPE_VIDEO:
3013 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
3014 av_log(s, AV_LOG_ERROR, "time base not set\n");
3015 ret = AVERROR(EINVAL);
3018 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
3019 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
3020 ret = AVERROR(EINVAL);
3023 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)
3024 && FFABS(av_q2d(st->sample_aspect_ratio) - av_q2d(st->codec->sample_aspect_ratio)) > 0.004*av_q2d(st->sample_aspect_ratio)
3026 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
3027 ret = AVERROR(EINVAL);
3033 if(s->oformat->codec_tag){
3034 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)){
3035 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
3036 st->codec->codec_tag= 0;
3038 if(st->codec->codec_tag){
3039 if (!validate_codec_tag(s, st)) {
3041 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
3042 av_log(s, AV_LOG_ERROR,
3043 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
3044 tagbuf, st->codec->codec_tag, st->codec->codec_id);
3045 ret = AVERROR_INVALIDDATA;
3049 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
3052 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
3053 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
3054 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
3057 if (!s->priv_data && s->oformat->priv_data_size > 0) {
3058 s->priv_data = av_mallocz(s->oformat->priv_data_size);
3059 if (!s->priv_data) {
3060 ret = AVERROR(ENOMEM);
3063 if (s->oformat->priv_class) {
3064 *(const AVClass**)s->priv_data= s->oformat->priv_class;
3065 av_opt_set_defaults(s->priv_data);
3066 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3071 /* set muxer identification string */
3072 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
3073 av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
3076 if(s->oformat->write_header){
3077 ret = s->oformat->write_header(s);
3082 /* init PTS generation */
3083 for(i=0;i<s->nb_streams;i++) {
3084 int64_t den = AV_NOPTS_VALUE;
3087 switch (st->codec->codec_type) {
3088 case AVMEDIA_TYPE_AUDIO:
3089 den = (int64_t)st->time_base.num * st->codec->sample_rate;
3091 case AVMEDIA_TYPE_VIDEO:
3092 den = (int64_t)st->time_base.num * st->codec->time_base.den;
3097 if (den != AV_NOPTS_VALUE) {
3099 ret = AVERROR_INVALIDDATA;
3102 frac_init(&st->pts, 0, 0, den);
3107 av_dict_free(options);
3116 //FIXME merge with compute_pkt_fields
3117 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3118 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3119 int num, den, frame_size, i;
3121 av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3122 pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3124 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
3125 return AVERROR(EINVAL);*/
3127 /* duration field */
3128 if (pkt->duration == 0) {
3129 compute_frame_duration(&num, &den, st, NULL, pkt);
3131 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3135 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3138 //XXX/FIXME this is a temporary hack until all encoders output pts
3139 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3141 // pkt->pts= st->cur_dts;
3142 pkt->pts= st->pts.val;
3145 //calculate dts from pts
3146 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3147 st->pts_buffer[0]= pkt->pts;
3148 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3149 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3150 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3151 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3153 pkt->dts= st->pts_buffer[0];
3156 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)){
3157 av_log(s, AV_LOG_ERROR,
3158 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3159 st->index, st->cur_dts, pkt->dts);
3160 return AVERROR(EINVAL);
3162 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3163 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3164 return AVERROR(EINVAL);
3167 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3168 st->cur_dts= pkt->dts;
3169 st->pts.val= pkt->dts;
3172 switch (st->codec->codec_type) {
3173 case AVMEDIA_TYPE_AUDIO:
3174 frame_size = get_audio_frame_size(st->codec, pkt->size);
3176 /* HACK/FIXME, we skip the initial 0 size packets as they are most
3177 likely equal to the encoder delay, but it would be better if we
3178 had the real timestamps from the encoder */
3179 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3180 frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3183 case AVMEDIA_TYPE_VIDEO:
3184 frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3192 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3194 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3196 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3199 ret= s->oformat->write_packet(s, pkt);
3202 s->streams[pkt->stream_index]->nb_frames++;
3206 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3207 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3209 AVPacketList **next_point, *this_pktl;
3211 this_pktl = av_mallocz(sizeof(AVPacketList));
3212 this_pktl->pkt= *pkt;
3213 pkt->destruct= NULL; // do not free original but only the copy
3214 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
3216 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3217 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3219 next_point = &s->packet_buffer;
3222 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3223 while(!compare(s, &(*next_point)->pkt, pkt)){
3224 next_point= &(*next_point)->next;
3228 next_point = &(s->packet_buffer_end->next);
3231 assert(!*next_point);
3233 s->packet_buffer_end= this_pktl;
3236 this_pktl->next= *next_point;
3238 s->streams[pkt->stream_index]->last_in_packet_buffer=
3239 *next_point= this_pktl;
3242 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3244 AVStream *st = s->streams[ pkt ->stream_index];
3245 AVStream *st2= s->streams[ next->stream_index];
3246 int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3250 return pkt->stream_index < next->stream_index;
3254 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3256 int stream_count=0, noninterleaved_count=0;
3257 int64_t delta_dts_max = 0;
3261 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3264 for(i=0; i < s->nb_streams; i++) {
3265 if (s->streams[i]->last_in_packet_buffer) {
3267 } else if(s->streams[i]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3268 ++noninterleaved_count;
3272 if (s->nb_streams == stream_count) {
3275 for(i=0; i < s->nb_streams; i++) {
3276 if (s->streams[i]->last_in_packet_buffer) {
3278 av_rescale_q(s->streams[i]->last_in_packet_buffer->pkt.dts,
3279 s->streams[i]->time_base,
3281 av_rescale_q(s->packet_buffer->pkt.dts,
3282 s->streams[s->packet_buffer->pkt.stream_index]->time_base,
3284 delta_dts_max= FFMAX(delta_dts_max, delta_dts);
3287 if(s->nb_streams == stream_count+noninterleaved_count &&
3288 delta_dts_max > 20*AV_TIME_BASE) {
3289 av_log(s, AV_LOG_DEBUG, "flushing with %d noninterleaved\n", noninterleaved_count);
3293 if(stream_count && flush){
3294 pktl= s->packet_buffer;
3297 s->packet_buffer= pktl->next;
3298 if(!s->packet_buffer)
3299 s->packet_buffer_end= NULL;
3301 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3302 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3306 av_init_packet(out);
3312 * Interleave an AVPacket correctly so it can be muxed.
3313 * @param out the interleaved packet will be output here
3314 * @param in the input packet
3315 * @param flush 1 if no further packets are available as input and all
3316 * remaining packets should be output
3317 * @return 1 if a packet was output, 0 if no packet could be output,
3318 * < 0 if an error occurred
3320 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3321 if(s->oformat->interleave_packet)
3322 return s->oformat->interleave_packet(s, out, in, flush);
3324 return av_interleave_packet_per_dts(s, out, in, flush);
3327 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3328 AVStream *st= s->streams[ pkt->stream_index];
3331 //FIXME/XXX/HACK drop zero sized packets
3332 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3335 av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3336 pkt->size, pkt->dts, pkt->pts);
3337 if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3340 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3341 return AVERROR(EINVAL);
3345 int ret= interleave_packet(s, &opkt, pkt, 0);
3346 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3349 ret= s->oformat->write_packet(s, &opkt);
3351 s->streams[opkt.stream_index]->nb_frames++;
3353 av_free_packet(&opkt);
3358 if(s->pb && s->pb->error)
3359 return s->pb->error;
3363 int av_write_trailer(AVFormatContext *s)
3369 ret= interleave_packet(s, &pkt, NULL, 1);
3370 if(ret<0) //FIXME cleanup needed for ret<0 ?
3375 ret= s->oformat->write_packet(s, &pkt);
3377 s->streams[pkt.stream_index]->nb_frames++;
3379 av_free_packet(&pkt);
3383 if(s->pb && s->pb->error)
3387 if(s->oformat->write_trailer)
3388 ret = s->oformat->write_trailer(s);
3391 ret = s->pb ? s->pb->error : 0;
3392 for(i=0;i<s->nb_streams;i++) {
3393 av_freep(&s->streams[i]->priv_data);
3394 av_freep(&s->streams[i]->index_entries);
3396 if (s->iformat && s->iformat->priv_class)
3397 av_opt_free(s->priv_data);
3398 av_freep(&s->priv_data);
3402 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
3403 int64_t *dts, int64_t *wall)
3405 if (!s->oformat || !s->oformat->get_output_timestamp)
3406 return AVERROR(ENOSYS);
3407 s->oformat->get_output_timestamp(s, stream, dts, wall);
3411 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3414 AVProgram *program=NULL;
3417 if (idx >= ac->nb_streams) {
3418 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3422 for(i=0; i<ac->nb_programs; i++){
3423 if(ac->programs[i]->id != progid)
3425 program = ac->programs[i];
3426 for(j=0; j<program->nb_stream_indexes; j++)
3427 if(program->stream_index[j] == idx)
3430 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3433 program->stream_index = tmp;
3434 program->stream_index[program->nb_stream_indexes++] = idx;
3439 static void print_fps(double d, const char *postfix){
3440 uint64_t v= lrintf(d*100);
3441 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3442 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3443 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3446 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3448 if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3449 AVDictionaryEntry *tag=NULL;
3451 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3452 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3453 if(strcmp("language", tag->key)){
3456 av_strlcpy(tmp, tag->value, sizeof(tmp));
3457 for(i=0; i<strlen(tmp); i++) if(tmp[i]==0xd) tmp[i]=' ';
3458 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tmp);
3464 /* "user interface" functions */
3465 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3468 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3469 AVStream *st = ic->streams[i];
3470 int g = av_gcd(st->time_base.num, st->time_base.den);
3471 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3472 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3473 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3474 /* the pid is an important information, so we display it */
3475 /* XXX: add a generic system */
3476 if (flags & AVFMT_SHOW_IDS)
3477 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3479 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3480 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3481 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3482 if (st->sample_aspect_ratio.num && // default
3483 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3484 AVRational display_aspect_ratio;
3485 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3486 st->codec->width*st->sample_aspect_ratio.num,
3487 st->codec->height*st->sample_aspect_ratio.den,
3489 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3490 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3491 display_aspect_ratio.num, display_aspect_ratio.den);
3493 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3494 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3495 print_fps(av_q2d(st->avg_frame_rate), "fps");
3496 if(st->r_frame_rate.den && st->r_frame_rate.num)
3497 print_fps(av_q2d(st->r_frame_rate), "tbr");
3498 if(st->time_base.den && st->time_base.num)
3499 print_fps(1/av_q2d(st->time_base), "tbn");
3500 if(st->codec->time_base.den && st->codec->time_base.num)
3501 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3503 if (st->disposition & AV_DISPOSITION_DEFAULT)
3504 av_log(NULL, AV_LOG_INFO, " (default)");
3505 if (st->disposition & AV_DISPOSITION_DUB)
3506 av_log(NULL, AV_LOG_INFO, " (dub)");
3507 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3508 av_log(NULL, AV_LOG_INFO, " (original)");
3509 if (st->disposition & AV_DISPOSITION_COMMENT)
3510 av_log(NULL, AV_LOG_INFO, " (comment)");
3511 if (st->disposition & AV_DISPOSITION_LYRICS)
3512 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3513 if (st->disposition & AV_DISPOSITION_KARAOKE)
3514 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3515 if (st->disposition & AV_DISPOSITION_FORCED)
3516 av_log(NULL, AV_LOG_INFO, " (forced)");
3517 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3518 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3519 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3520 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3521 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3522 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3523 av_log(NULL, AV_LOG_INFO, "\n");
3524 dump_metadata(NULL, st->metadata, " ");
3527 #if FF_API_DUMP_FORMAT
3528 void dump_format(AVFormatContext *ic,
3533 av_dump_format(ic, index, url, is_output);
3537 void av_dump_format(AVFormatContext *ic,
3543 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3544 if (ic->nb_streams && !printed)
3547 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3548 is_output ? "Output" : "Input",
3550 is_output ? ic->oformat->name : ic->iformat->name,
3551 is_output ? "to" : "from", url);
3552 dump_metadata(NULL, ic->metadata, " ");
3554 av_log(NULL, AV_LOG_INFO, " Duration: ");
3555 if (ic->duration != AV_NOPTS_VALUE) {
3556 int hours, mins, secs, us;
3557 secs = ic->duration / AV_TIME_BASE;
3558 us = ic->duration % AV_TIME_BASE;
3563 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3564 (100 * us) / AV_TIME_BASE);
3566 av_log(NULL, AV_LOG_INFO, "N/A");
3568 if (ic->start_time != AV_NOPTS_VALUE) {
3570 av_log(NULL, AV_LOG_INFO, ", start: ");
3571 secs = ic->start_time / AV_TIME_BASE;
3572 us = abs(ic->start_time % AV_TIME_BASE);
3573 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3574 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3576 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3578 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3580 av_log(NULL, AV_LOG_INFO, "N/A");
3582 av_log(NULL, AV_LOG_INFO, "\n");
3584 for (i = 0; i < ic->nb_chapters; i++) {
3585 AVChapter *ch = ic->chapters[i];
3586 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3587 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3588 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3590 dump_metadata(NULL, ch->metadata, " ");
3592 if(ic->nb_programs) {
3593 int j, k, total = 0;
3594 for(j=0; j<ic->nb_programs; j++) {
3595 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3597 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3598 name ? name->value : "");
3599 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3600 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3601 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3602 printed[ic->programs[j]->stream_index[k]] = 1;
3604 total += ic->programs[j]->nb_stream_indexes;
3606 if (total < ic->nb_streams)
3607 av_log(NULL, AV_LOG_INFO, " No Program\n");
3609 for(i=0;i<ic->nb_streams;i++)
3611 dump_stream_format(ic, i, index, is_output);
3616 int64_t av_gettime(void)
3619 gettimeofday(&tv,NULL);
3620 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3623 uint64_t ff_ntp_time(void)
3625 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3628 #if FF_API_PARSE_DATE
3629 #include "libavutil/parseutils.h"
3631 int64_t parse_date(const char *timestr, int duration)
3634 av_parse_time(&timeval, timestr, duration);
3639 #if FF_API_FIND_INFO_TAG
3640 #include "libavutil/parseutils.h"
3642 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3644 return av_find_info_tag(arg, arg_size, tag1, info);
3648 int av_get_frame_filename(char *buf, int buf_size,
3649 const char *path, int number)
3652 char *q, buf1[20], c;
3653 int nd, len, percentd_found;
3665 while (isdigit(*p)) {
3666 nd = nd * 10 + *p++ - '0';
3669 } while (isdigit(c));
3678 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3680 if ((q - buf + len) > buf_size - 1)
3682 memcpy(q, buf1, len);
3690 if ((q - buf) < buf_size - 1)
3694 if (!percentd_found)
3703 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3707 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3709 for(i=0;i<size;i+=16) {
3716 PRINT(" %02x", buf[i+j]);
3721 for(j=0;j<len;j++) {
3723 if (c < ' ' || c > '~')
3732 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3734 hex_dump_internal(NULL, f, 0, buf, size);
3737 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3739 hex_dump_internal(avcl, NULL, level, buf, size);
3742 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3745 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3746 PRINT("stream #%d:\n", pkt->stream_index);
3747 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3748 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3749 /* DTS is _always_ valid after av_read_frame() */
3751 if (pkt->dts == AV_NOPTS_VALUE)
3754 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3755 /* PTS may not be known if B-frames are present. */
3757 if (pkt->pts == AV_NOPTS_VALUE)
3760 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3762 PRINT(" size=%d\n", pkt->size);
3765 av_hex_dump(f, pkt->data, pkt->size);
3769 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3771 AVRational tb = { 1, AV_TIME_BASE };
3772 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3776 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3778 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3782 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3784 AVRational tb = { 1, AV_TIME_BASE };
3785 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3789 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3792 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3795 void av_url_split(char *proto, int proto_size,
3796 char *authorization, int authorization_size,
3797 char *hostname, int hostname_size,
3799 char *path, int path_size,
3802 const char *p, *ls, *at, *col, *brk;
3804 if (port_ptr) *port_ptr = -1;
3805 if (proto_size > 0) proto[0] = 0;
3806 if (authorization_size > 0) authorization[0] = 0;
3807 if (hostname_size > 0) hostname[0] = 0;
3808 if (path_size > 0) path[0] = 0;
3810 /* parse protocol */
3811 if ((p = strchr(url, ':'))) {
3812 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3817 /* no protocol means plain filename */
3818 av_strlcpy(path, url, path_size);
3822 /* separate path from hostname */
3823 ls = strchr(p, '/');
3825 ls = strchr(p, '?');
3827 av_strlcpy(path, ls, path_size);
3829 ls = &p[strlen(p)]; // XXX
3831 /* the rest is hostname, use that to parse auth/port */
3833 /* authorization (user[:pass]@hostname) */
3834 if ((at = strchr(p, '@')) && at < ls) {
3835 av_strlcpy(authorization, p,
3836 FFMIN(authorization_size, at + 1 - p));
3837 p = at + 1; /* skip '@' */
3840 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3842 av_strlcpy(hostname, p + 1,
3843 FFMIN(hostname_size, brk - p));
3844 if (brk[1] == ':' && port_ptr)
3845 *port_ptr = atoi(brk + 2);
3846 } else if ((col = strchr(p, ':')) && col < ls) {
3847 av_strlcpy(hostname, p,
3848 FFMIN(col + 1 - p, hostname_size));
3849 if (port_ptr) *port_ptr = atoi(col + 1);
3851 av_strlcpy(hostname, p,
3852 FFMIN(ls + 1 - p, hostname_size));
3856 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3859 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3862 'C', 'D', 'E', 'F' };
3863 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3866 'c', 'd', 'e', 'f' };
3867 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3869 for(i = 0; i < s; i++) {
3870 buff[i * 2] = hex_table[src[i] >> 4];
3871 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3877 int ff_hex_to_data(uint8_t *data, const char *p)
3884 p += strspn(p, SPACE_CHARS);
3887 c = toupper((unsigned char) *p++);
3888 if (c >= '0' && c <= '9')
3890 else if (c >= 'A' && c <= 'F')
3905 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3906 unsigned int pts_num, unsigned int pts_den)
3909 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3910 if(new_tb.num != pts_num)
3911 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3913 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3915 if(new_tb.num <= 0 || new_tb.den <= 0) {
3916 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3919 s->time_base = new_tb;
3920 s->pts_wrap_bits = pts_wrap_bits;
3923 int ff_url_join(char *str, int size, const char *proto,
3924 const char *authorization, const char *hostname,
3925 int port, const char *fmt, ...)
3928 struct addrinfo hints, *ai;
3933 av_strlcatf(str, size, "%s://", proto);
3934 if (authorization && authorization[0])
3935 av_strlcatf(str, size, "%s@", authorization);
3936 #if CONFIG_NETWORK && defined(AF_INET6)
3937 /* Determine if hostname is a numerical IPv6 address,
3938 * properly escape it within [] in that case. */
3939 memset(&hints, 0, sizeof(hints));
3940 hints.ai_flags = AI_NUMERICHOST;
3941 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3942 if (ai->ai_family == AF_INET6) {
3943 av_strlcat(str, "[", size);
3944 av_strlcat(str, hostname, size);
3945 av_strlcat(str, "]", size);
3947 av_strlcat(str, hostname, size);
3952 /* Not an IPv6 address, just output the plain string. */
3953 av_strlcat(str, hostname, size);
3956 av_strlcatf(str, size, ":%d", port);
3959 int len = strlen(str);
3962 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3968 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3969 AVFormatContext *src)
3974 local_pkt.stream_index = dst_stream;
3975 if (pkt->pts != AV_NOPTS_VALUE)
3976 local_pkt.pts = av_rescale_q(pkt->pts,
3977 src->streams[pkt->stream_index]->time_base,
3978 dst->streams[dst_stream]->time_base);
3979 if (pkt->dts != AV_NOPTS_VALUE)
3980 local_pkt.dts = av_rescale_q(pkt->dts,
3981 src->streams[pkt->stream_index]->time_base,
3982 dst->streams[dst_stream]->time_base);
3983 return av_write_frame(dst, &local_pkt);
3986 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3989 const char *ptr = str;
3991 /* Parse key=value pairs. */
3994 char *dest = NULL, *dest_end;
3995 int key_len, dest_len = 0;
3997 /* Skip whitespace and potential commas. */
3998 while (*ptr && (isspace(*ptr) || *ptr == ','))
4005 if (!(ptr = strchr(key, '=')))
4008 key_len = ptr - key;
4010 callback_get_buf(context, key, key_len, &dest, &dest_len);
4011 dest_end = dest + dest_len - 1;
4015 while (*ptr && *ptr != '\"') {
4019 if (dest && dest < dest_end)
4023 if (dest && dest < dest_end)
4031 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
4032 if (dest && dest < dest_end)
4040 int ff_find_stream_index(AVFormatContext *s, int id)
4043 for (i = 0; i < s->nb_streams; i++) {
4044 if (s->streams[i]->id == id)
4050 void ff_make_absolute_url(char *buf, int size, const char *base,
4054 /* Absolute path, relative to the current server */
4055 if (base && strstr(base, "://") && rel[0] == '/') {
4057 av_strlcpy(buf, base, size);
4058 sep = strstr(buf, "://");
4061 sep = strchr(sep, '/');
4065 av_strlcat(buf, rel, size);
4068 /* If rel actually is an absolute url, just copy it */
4069 if (!base || strstr(rel, "://") || rel[0] == '/') {
4070 av_strlcpy(buf, rel, size);
4074 av_strlcpy(buf, base, size);
4075 /* Remove the file name from the base url */
4076 sep = strrchr(buf, '/');
4081 while (av_strstart(rel, "../", NULL) && sep) {
4082 /* Remove the path delimiter at the end */
4084 sep = strrchr(buf, '/');
4085 /* If the next directory name to pop off is "..", break here */
4086 if (!strcmp(sep ? &sep[1] : buf, "..")) {
4087 /* Readd the slash we just removed */
4088 av_strlcat(buf, "/", size);
4091 /* Cut off the directory name */
4098 av_strlcat(buf, rel, size);
4101 int64_t ff_iso8601_to_unix_time(const char *datestr)
4104 struct tm time = {0};
4105 strptime(datestr, "%Y - %m - %dT%T", &time);
4106 return mktime(&time);
4108 av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
4109 "the date string.\n");
4114 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
4117 if (ofmt->query_codec)
4118 return ofmt->query_codec(codec_id, std_compliance);
4119 else if (ofmt->codec_tag)
4120 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4121 else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4122 codec_id == ofmt->subtitle_codec)
4125 return AVERROR_PATCHWELCOME;