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 { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
373 { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
374 { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
378 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
382 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
383 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
384 for (i = 0; fmt_id_type[i].name; i++) {
385 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
386 st->codec->codec_id = fmt_id_type[i].id;
387 st->codec->codec_type = fmt_id_type[i].type;
395 /************************************************************/
396 /* input media file */
398 #if FF_API_FORMAT_PARAMETERS
399 static AVDictionary *convert_format_parameters(AVFormatParameters *ap)
402 AVDictionary *opts = NULL;
407 if (ap->time_base.num) {
408 snprintf(buf, sizeof(buf), "%d/%d", ap->time_base.den, ap->time_base.num);
409 av_dict_set(&opts, "framerate", buf, 0);
411 if (ap->sample_rate) {
412 snprintf(buf, sizeof(buf), "%d", ap->sample_rate);
413 av_dict_set(&opts, "sample_rate", buf, 0);
416 snprintf(buf, sizeof(buf), "%d", ap->channels);
417 av_dict_set(&opts, "channels", buf, 0);
419 if (ap->width || ap->height) {
420 snprintf(buf, sizeof(buf), "%dx%d", ap->width, ap->height);
421 av_dict_set(&opts, "video_size", buf, 0);
423 if (ap->pix_fmt != PIX_FMT_NONE) {
424 av_dict_set(&opts, "pixel_format", av_get_pix_fmt_name(ap->pix_fmt), 0);
427 snprintf(buf, sizeof(buf), "%d", ap->channel);
428 av_dict_set(&opts, "channel", buf, 0);
431 av_dict_set(&opts, "standard", ap->standard, 0);
433 if (ap->mpeg2ts_compute_pcr) {
434 av_dict_set(&opts, "mpeg2ts_compute_pcr", "1", 0);
436 if (ap->initial_pause) {
437 av_dict_set(&opts, "initial_pause", "1", 0);
443 * Open a media file from an IO stream. 'fmt' must be specified.
445 int av_open_input_stream(AVFormatContext **ic_ptr,
446 AVIOContext *pb, const char *filename,
447 AVInputFormat *fmt, AVFormatParameters *ap)
452 AVFormatParameters default_ap;
456 memset(ap, 0, sizeof(default_ap));
458 opts = convert_format_parameters(ap);
460 if(!ap->prealloced_context)
461 *ic_ptr = ic = avformat_alloc_context();
465 err = AVERROR(ENOMEM);
468 if (pb && fmt && fmt->flags & AVFMT_NOFILE)
469 av_log(ic, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
470 "will be ignored with AVFMT_NOFILE format.\n");
474 if ((err = avformat_open_input(&ic, filename, fmt, &opts)) < 0)
476 ic->pb = ic->pb ? ic->pb : pb; // don't leak custom pb if it wasn't set above
485 int av_demuxer_open(AVFormatContext *ic, AVFormatParameters *ap){
488 if (ic->iformat->read_header) {
489 err = ic->iformat->read_header(ic, ap);
494 if (ic->pb && !ic->data_offset)
495 ic->data_offset = avio_tell(ic->pb);
501 /** size of probe buffer, for guessing file type from file contents */
502 #define PROBE_BUF_MIN 2048
503 #define PROBE_BUF_MAX (1<<20)
505 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
506 const char *filename, void *logctx,
507 unsigned int offset, unsigned int max_probe_size)
509 AVProbeData pd = { filename ? filename : "", NULL, -offset };
510 unsigned char *buf = NULL;
511 int ret = 0, probe_size;
513 if (!max_probe_size) {
514 max_probe_size = PROBE_BUF_MAX;
515 } else if (max_probe_size > PROBE_BUF_MAX) {
516 max_probe_size = PROBE_BUF_MAX;
517 } else if (max_probe_size < PROBE_BUF_MIN) {
518 return AVERROR(EINVAL);
521 if (offset >= max_probe_size) {
522 return AVERROR(EINVAL);
525 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
526 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
527 int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
528 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
530 if (probe_size < offset) {
534 /* read probe data */
535 buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
536 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
537 /* fail if error was not end of file, otherwise, lower score */
538 if (ret != AVERROR_EOF) {
543 ret = 0; /* error was end of file, nothing read */
546 pd.buf = &buf[offset];
548 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
550 /* guess file format */
551 *fmt = av_probe_input_format2(&pd, 1, &score);
553 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
554 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
556 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
562 return AVERROR_INVALIDDATA;
565 /* rewind. reuse probe buffer to avoid seeking */
566 if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
572 #if FF_API_FORMAT_PARAMETERS
573 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
576 AVFormatParameters *ap)
579 AVDictionary *opts = convert_format_parameters(ap);
581 if (!ap || !ap->prealloced_context)
584 err = avformat_open_input(ic_ptr, filename, fmt, &opts);
591 /* open input file and probe the format if necessary */
592 static int init_input(AVFormatContext *s, const char *filename)
595 AVProbeData pd = {filename, NULL, 0};
598 s->flags |= AVFMT_FLAG_CUSTOM_IO;
600 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
601 else if (s->iformat->flags & AVFMT_NOFILE)
602 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
603 "will be ignored with AVFMT_NOFILE format.\n");
607 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
608 (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
611 if ((ret = avio_open(&s->pb, filename, AVIO_FLAG_READ)) < 0)
615 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
618 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
620 AVFormatContext *s = *ps;
622 AVFormatParameters ap = { { 0 } };
623 AVDictionary *tmp = NULL;
625 if (!s && !(s = avformat_alloc_context()))
626 return AVERROR(ENOMEM);
631 av_dict_copy(&tmp, *options, 0);
633 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
636 if ((ret = init_input(s, filename)) < 0)
639 /* check filename in case an image number is expected */
640 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
641 if (!av_filename_number_test(filename)) {
642 ret = AVERROR(EINVAL);
647 s->duration = s->start_time = AV_NOPTS_VALUE;
648 av_strlcpy(s->filename, filename, sizeof(s->filename));
650 /* allocate private data */
651 if (s->iformat->priv_data_size > 0) {
652 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
653 ret = AVERROR(ENOMEM);
656 if (s->iformat->priv_class) {
657 *(const AVClass**)s->priv_data = s->iformat->priv_class;
658 av_opt_set_defaults(s->priv_data);
659 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
664 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
666 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC);
668 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
669 if ((ret = s->iformat->read_header(s, &ap)) < 0)
672 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
673 s->data_offset = avio_tell(s->pb);
675 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
678 av_dict_free(options);
686 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
688 avformat_free_context(s);
693 /*******************************************************/
695 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
696 AVPacketList **plast_pktl){
697 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
702 (*plast_pktl)->next = pktl;
704 *packet_buffer = pktl;
706 /* add the packet in the buffered packet list */
712 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
718 AVPacketList *pktl = s->raw_packet_buffer;
722 if(s->streams[pkt->stream_index]->request_probe <= 0){
723 s->raw_packet_buffer = pktl->next;
724 s->raw_packet_buffer_remaining_size += pkt->size;
731 ret= s->iformat->read_packet(s, pkt);
733 if (!pktl || ret == AVERROR(EAGAIN))
735 for (i = 0; i < s->nb_streams; i++)
736 if(s->streams[i]->request_probe > 0)
737 s->streams[i]->request_probe = -1;
741 if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
742 av_packet_merge_side_data(pkt);
743 st= s->streams[pkt->stream_index];
745 switch(st->codec->codec_type){
746 case AVMEDIA_TYPE_VIDEO:
747 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
749 case AVMEDIA_TYPE_AUDIO:
750 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
752 case AVMEDIA_TYPE_SUBTITLE:
753 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
757 if(!pktl && st->request_probe <= 0)
760 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
761 s->raw_packet_buffer_remaining_size -= pkt->size;
763 if(st->request_probe>0){
764 AVProbeData *pd = &st->probe_data;
766 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
769 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
770 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
771 pd->buf_size += pkt->size;
772 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
774 end= s->raw_packet_buffer_remaining_size <= 0
775 || st->probe_packets<=0;
777 if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
778 int score= set_codec_from_probe_data(s, st, pd);
779 if( (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
783 st->request_probe= -1;
784 if(st->codec->codec_id != CODEC_ID_NONE){
785 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
787 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
794 /**********************************************************/
797 * Get the number of samples of an audio frame. Return -1 on error.
799 static int get_audio_frame_size(AVCodecContext *enc, int size)
803 if(enc->codec_id == CODEC_ID_VORBIS)
806 if (enc->frame_size <= 1) {
807 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
809 if (bits_per_sample) {
810 if (enc->channels == 0)
812 frame_size = (size << 3) / (bits_per_sample * enc->channels);
814 /* used for example by ADPCM codecs */
815 if (enc->bit_rate == 0)
817 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
820 frame_size = enc->frame_size;
827 * Return the frame duration in seconds. Return 0 if not available.
829 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
830 AVCodecParserContext *pc, AVPacket *pkt)
836 switch(st->codec->codec_type) {
837 case AVMEDIA_TYPE_VIDEO:
838 if(st->time_base.num*1000LL > st->time_base.den){
839 *pnum = st->time_base.num;
840 *pden = st->time_base.den;
841 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
842 *pnum = st->codec->time_base.num;
843 *pden = st->codec->time_base.den;
844 if (pc && pc->repeat_pict) {
845 *pnum = (*pnum) * (1 + pc->repeat_pict);
847 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
848 //Thus if we have no parser in such case leave duration undefined.
849 if(st->codec->ticks_per_frame>1 && !pc){
854 case AVMEDIA_TYPE_AUDIO:
855 frame_size = get_audio_frame_size(st->codec, pkt->size);
856 if (frame_size <= 0 || st->codec->sample_rate <= 0)
859 *pden = st->codec->sample_rate;
866 static int is_intra_only(AVCodecContext *enc){
867 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
869 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
870 switch(enc->codec_id){
872 case CODEC_ID_MJPEGB:
874 case CODEC_ID_RAWVIDEO:
875 case CODEC_ID_DVVIDEO:
876 case CODEC_ID_HUFFYUV:
877 case CODEC_ID_FFVHUFF:
882 case CODEC_ID_JPEG2000:
890 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
891 int64_t dts, int64_t pts)
893 AVStream *st= s->streams[stream_index];
894 AVPacketList *pktl= s->packet_buffer;
896 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
899 st->first_dts= dts - st->cur_dts;
902 for(; pktl; pktl= pktl->next){
903 if(pktl->pkt.stream_index != stream_index)
905 //FIXME think more about this check
906 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
907 pktl->pkt.pts += st->first_dts;
909 if(pktl->pkt.dts != AV_NOPTS_VALUE)
910 pktl->pkt.dts += st->first_dts;
912 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
913 st->start_time= pktl->pkt.pts;
915 if (st->start_time == AV_NOPTS_VALUE)
916 st->start_time = pts;
919 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
921 AVPacketList *pktl= s->packet_buffer;
924 if(st->first_dts != AV_NOPTS_VALUE){
925 cur_dts= st->first_dts;
926 for(; pktl; pktl= pktl->next){
927 if(pktl->pkt.stream_index == pkt->stream_index){
928 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
930 cur_dts -= pkt->duration;
933 pktl= s->packet_buffer;
934 st->first_dts = cur_dts;
935 }else if(st->cur_dts)
938 for(; pktl; pktl= pktl->next){
939 if(pktl->pkt.stream_index != pkt->stream_index)
941 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
942 && !pktl->pkt.duration){
943 pktl->pkt.dts= cur_dts;
944 if(!st->codec->has_b_frames)
945 pktl->pkt.pts= cur_dts;
946 cur_dts += pkt->duration;
947 pktl->pkt.duration= pkt->duration;
951 if(st->first_dts == AV_NOPTS_VALUE)
952 st->cur_dts= cur_dts;
955 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
956 AVCodecParserContext *pc, AVPacket *pkt)
958 int num, den, presentation_delayed, delay, i;
961 if (s->flags & AVFMT_FLAG_NOFILLIN)
964 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
965 pkt->dts= AV_NOPTS_VALUE;
967 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
968 //FIXME Set low_delay = 0 when has_b_frames = 1
969 st->codec->has_b_frames = 1;
971 /* do we have a video B-frame ? */
972 delay= st->codec->has_b_frames;
973 presentation_delayed = 0;
975 // ignore delay caused by frame threading so that the mpeg2-without-dts
976 // warning will not trigger
977 if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
978 delay -= st->codec->thread_count-1;
980 /* XXX: need has_b_frame, but cannot get it if the codec is
983 pc && pc->pict_type != AV_PICTURE_TYPE_B)
984 presentation_delayed = 1;
986 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
987 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
988 pkt->dts -= 1LL<<st->pts_wrap_bits;
991 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
992 // we take the conservative approach and discard both
993 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
994 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
995 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
996 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
999 if (pkt->duration == 0) {
1000 compute_frame_duration(&num, &den, st, pc, pkt);
1002 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1004 if(pkt->duration != 0 && s->packet_buffer)
1005 update_initial_durations(s, st, pkt);
1009 /* correct timestamps with byte offset if demuxers only have timestamps
1010 on packet boundaries */
1011 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1012 /* this will estimate bitrate based on this frame's duration and size */
1013 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1014 if(pkt->pts != AV_NOPTS_VALUE)
1016 if(pkt->dts != AV_NOPTS_VALUE)
1020 if (pc && pc->dts_sync_point >= 0) {
1021 // we have synchronization info from the parser
1022 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1024 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1025 if (pkt->dts != AV_NOPTS_VALUE) {
1026 // got DTS from the stream, update reference timestamp
1027 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1028 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1029 } else if (st->reference_dts != AV_NOPTS_VALUE) {
1030 // compute DTS based on reference timestamp
1031 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1032 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1034 if (pc->dts_sync_point > 0)
1035 st->reference_dts = pkt->dts; // new reference
1039 /* This may be redundant, but it should not hurt. */
1040 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1041 presentation_delayed = 1;
1043 // 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);
1044 /* interpolate PTS and DTS if they are not present */
1045 //We skip H264 currently because delay and has_b_frames are not reliably set
1046 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1047 if (presentation_delayed) {
1048 /* DTS = decompression timestamp */
1049 /* PTS = presentation timestamp */
1050 if (pkt->dts == AV_NOPTS_VALUE)
1051 pkt->dts = st->last_IP_pts;
1052 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1053 if (pkt->dts == AV_NOPTS_VALUE)
1054 pkt->dts = st->cur_dts;
1056 /* this is tricky: the dts must be incremented by the duration
1057 of the frame we are displaying, i.e. the last I- or P-frame */
1058 if (st->last_IP_duration == 0)
1059 st->last_IP_duration = pkt->duration;
1060 if(pkt->dts != AV_NOPTS_VALUE)
1061 st->cur_dts = pkt->dts + st->last_IP_duration;
1062 st->last_IP_duration = pkt->duration;
1063 st->last_IP_pts= pkt->pts;
1064 /* cannot compute PTS if not present (we can compute it only
1065 by knowing the future */
1066 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1067 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1068 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1069 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1070 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1071 pkt->pts += pkt->duration;
1072 // 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);
1076 /* presentation is not delayed : PTS and DTS are the same */
1077 if(pkt->pts == AV_NOPTS_VALUE)
1078 pkt->pts = pkt->dts;
1079 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1080 if(pkt->pts == AV_NOPTS_VALUE)
1081 pkt->pts = st->cur_dts;
1082 pkt->dts = pkt->pts;
1083 if(pkt->pts != AV_NOPTS_VALUE)
1084 st->cur_dts = pkt->pts + pkt->duration;
1088 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1089 st->pts_buffer[0]= pkt->pts;
1090 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1091 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1092 if(pkt->dts == AV_NOPTS_VALUE)
1093 pkt->dts= st->pts_buffer[0];
1094 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1095 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1097 if(pkt->dts > st->cur_dts)
1098 st->cur_dts = pkt->dts;
1101 // 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);
1104 if(is_intra_only(st->codec))
1105 pkt->flags |= AV_PKT_FLAG_KEY;
1108 /* keyframe computation */
1109 if (pc->key_frame == 1)
1110 pkt->flags |= AV_PKT_FLAG_KEY;
1111 else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
1112 pkt->flags |= AV_PKT_FLAG_KEY;
1115 pkt->convergence_duration = pc->convergence_duration;
1119 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1124 av_init_packet(pkt);
1127 /* select current input stream component */
1130 if (!st->need_parsing || !st->parser) {
1131 /* no parsing needed: we just output the packet as is */
1132 /* raw data support */
1133 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1134 compute_pkt_fields(s, st, NULL, pkt);
1136 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1137 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1138 ff_reduce_index(s, st->index);
1139 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1142 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1143 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1144 st->cur_ptr, st->cur_len,
1145 st->cur_pkt.pts, st->cur_pkt.dts,
1147 st->cur_pkt.pts = AV_NOPTS_VALUE;
1148 st->cur_pkt.dts = AV_NOPTS_VALUE;
1149 /* increment read pointer */
1153 /* return packet if any */
1157 pkt->stream_index = st->index;
1158 pkt->pts = st->parser->pts;
1159 pkt->dts = st->parser->dts;
1160 pkt->pos = st->parser->pos;
1161 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1163 pkt->destruct= st->cur_pkt.destruct;
1164 st->cur_pkt.destruct= NULL;
1165 st->cur_pkt.data = NULL;
1166 assert(st->cur_len == 0);
1168 pkt->destruct = NULL;
1170 compute_pkt_fields(s, st, st->parser, pkt);
1172 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1173 int64_t pos= (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->pos : st->parser->frame_offset;
1174 ff_reduce_index(s, st->index);
1175 av_add_index_entry(st, pos, pkt->dts,
1176 0, 0, AVINDEX_KEYFRAME);
1183 av_free_packet(&st->cur_pkt);
1188 /* read next packet */
1189 ret = av_read_packet(s, &cur_pkt);
1191 if (ret == AVERROR(EAGAIN))
1193 /* return the last frames, if any */
1194 for(i = 0; i < s->nb_streams; i++) {
1196 if (st->parser && st->need_parsing) {
1197 av_parser_parse2(st->parser, st->codec,
1198 &pkt->data, &pkt->size,
1200 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1206 /* no more packets: really terminate parsing */
1209 st = s->streams[cur_pkt.stream_index];
1210 st->cur_pkt= cur_pkt;
1212 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1213 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1214 st->cur_pkt.pts < st->cur_pkt.dts){
1215 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1216 st->cur_pkt.stream_index,
1220 // av_free_packet(&st->cur_pkt);
1224 if(s->debug & FF_FDEBUG_TS)
1225 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1226 st->cur_pkt.stream_index,
1230 st->cur_pkt.duration,
1234 st->cur_ptr = st->cur_pkt.data;
1235 st->cur_len = st->cur_pkt.size;
1236 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1237 st->parser = av_parser_init(st->codec->codec_id);
1239 /* no parser available: just output the raw packets */
1240 st->need_parsing = AVSTREAM_PARSE_NONE;
1241 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1242 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1243 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1244 st->parser->flags |= PARSER_FLAG_ONCE;
1249 if(s->debug & FF_FDEBUG_TS)
1250 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1261 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1265 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1268 pktl = s->packet_buffer;
1270 AVPacket *next_pkt= &pktl->pkt;
1272 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1273 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1274 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1275 if( pktl->pkt.stream_index == next_pkt->stream_index
1276 && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1277 && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1278 next_pkt->pts= pktl->pkt.dts;
1282 pktl = s->packet_buffer;
1285 if( next_pkt->pts != AV_NOPTS_VALUE
1286 || next_pkt->dts == AV_NOPTS_VALUE
1288 /* read packet from packet buffer, if there is data */
1290 s->packet_buffer = pktl->next;
1296 int ret= read_frame_internal(s, pkt);
1298 if(pktl && ret != AVERROR(EAGAIN)){
1305 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1306 &s->packet_buffer_end)) < 0)
1307 return AVERROR(ENOMEM);
1309 assert(!s->packet_buffer);
1310 return read_frame_internal(s, pkt);
1315 /* XXX: suppress the packet queue */
1316 static void flush_packet_queue(AVFormatContext *s)
1321 pktl = s->packet_buffer;
1324 s->packet_buffer = pktl->next;
1325 av_free_packet(&pktl->pkt);
1328 while(s->raw_packet_buffer){
1329 pktl = s->raw_packet_buffer;
1330 s->raw_packet_buffer = pktl->next;
1331 av_free_packet(&pktl->pkt);
1334 s->packet_buffer_end=
1335 s->raw_packet_buffer_end= NULL;
1336 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1339 /*******************************************************/
1342 int av_find_default_stream_index(AVFormatContext *s)
1344 int first_audio_index = -1;
1348 if (s->nb_streams <= 0)
1350 for(i = 0; i < s->nb_streams; i++) {
1352 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1355 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1356 first_audio_index = i;
1358 return first_audio_index >= 0 ? first_audio_index : 0;
1362 * Flush the frame reader.
1364 void ff_read_frame_flush(AVFormatContext *s)
1369 flush_packet_queue(s);
1373 /* for each stream, reset read state */
1374 for(i = 0; i < s->nb_streams; i++) {
1378 av_parser_close(st->parser);
1380 av_free_packet(&st->cur_pkt);
1382 st->last_IP_pts = AV_NOPTS_VALUE;
1383 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1384 st->reference_dts = AV_NOPTS_VALUE;
1389 st->probe_packets = MAX_PROBE_PACKETS;
1391 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1392 st->pts_buffer[j]= AV_NOPTS_VALUE;
1396 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1399 for(i = 0; i < s->nb_streams; i++) {
1400 AVStream *st = s->streams[i];
1402 st->cur_dts = av_rescale(timestamp,
1403 st->time_base.den * (int64_t)ref_st->time_base.num,
1404 st->time_base.num * (int64_t)ref_st->time_base.den);
1408 void ff_reduce_index(AVFormatContext *s, int stream_index)
1410 AVStream *st= s->streams[stream_index];
1411 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1413 if((unsigned)st->nb_index_entries >= max_entries){
1415 for(i=0; 2*i<st->nb_index_entries; i++)
1416 st->index_entries[i]= st->index_entries[2*i];
1417 st->nb_index_entries= i;
1421 int ff_add_index_entry(AVIndexEntry **index_entries,
1422 int *nb_index_entries,
1423 unsigned int *index_entries_allocated_size,
1424 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1426 AVIndexEntry *entries, *ie;
1429 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1432 entries = av_fast_realloc(*index_entries,
1433 index_entries_allocated_size,
1434 (*nb_index_entries + 1) *
1435 sizeof(AVIndexEntry));
1439 *index_entries= entries;
1441 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1444 index= (*nb_index_entries)++;
1445 ie= &entries[index];
1446 assert(index==0 || ie[-1].timestamp < timestamp);
1448 ie= &entries[index];
1449 if(ie->timestamp != timestamp){
1450 if(ie->timestamp <= timestamp)
1452 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1453 (*nb_index_entries)++;
1454 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1455 distance= ie->min_distance;
1459 ie->timestamp = timestamp;
1460 ie->min_distance= distance;
1467 int av_add_index_entry(AVStream *st,
1468 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1470 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1471 &st->index_entries_allocated_size, pos,
1472 timestamp, size, distance, flags);
1475 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1476 int64_t wanted_timestamp, int flags)
1484 //optimize appending index entries at the end
1485 if(b && entries[b-1].timestamp < wanted_timestamp)
1490 timestamp = entries[m].timestamp;
1491 if(timestamp >= wanted_timestamp)
1493 if(timestamp <= wanted_timestamp)
1496 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1498 if(!(flags & AVSEEK_FLAG_ANY)){
1499 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1500 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1509 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1512 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1513 wanted_timestamp, flags);
1516 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1517 AVInputFormat *avif= s->iformat;
1518 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1519 int64_t ts_min, ts_max, ts;
1524 if (stream_index < 0)
1527 av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1530 ts_min= AV_NOPTS_VALUE;
1531 pos_limit= -1; //gcc falsely says it may be uninitialized
1533 st= s->streams[stream_index];
1534 if(st->index_entries){
1537 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()
1538 index= FFMAX(index, 0);
1539 e= &st->index_entries[index];
1541 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1543 ts_min= e->timestamp;
1544 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1550 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1551 assert(index < st->nb_index_entries);
1553 e= &st->index_entries[index];
1554 assert(e->timestamp >= target_ts);
1556 ts_max= e->timestamp;
1557 pos_limit= pos_max - e->min_distance;
1558 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1559 pos_max,pos_limit, ts_max);
1563 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1568 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1571 av_update_cur_dts(s, st, ts);
1576 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 )){
1578 int64_t start_pos, filesize;
1581 av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1583 if(ts_min == AV_NOPTS_VALUE){
1584 pos_min = s->data_offset;
1585 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1586 if (ts_min == AV_NOPTS_VALUE)
1590 if(ts_max == AV_NOPTS_VALUE){
1592 filesize = avio_size(s->pb);
1593 pos_max = filesize - 1;
1596 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1598 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1599 if (ts_max == AV_NOPTS_VALUE)
1603 int64_t tmp_pos= pos_max + 1;
1604 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1605 if(tmp_ts == AV_NOPTS_VALUE)
1609 if(tmp_pos >= filesize)
1615 if(ts_min > ts_max){
1617 }else if(ts_min == ts_max){
1622 while (pos_min < pos_limit) {
1623 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1624 pos_min, pos_max, ts_min, ts_max);
1625 assert(pos_limit <= pos_max);
1628 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1629 // interpolate position (better than dichotomy)
1630 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1631 + pos_min - approximate_keyframe_distance;
1632 }else if(no_change==1){
1633 // bisection, if interpolation failed to change min or max pos last time
1634 pos = (pos_min + pos_limit)>>1;
1636 /* linear search if bisection failed, can only happen if there
1637 are very few or no keyframes between min/max */
1642 else if(pos > pos_limit)
1646 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1651 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1652 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1653 pos_limit, start_pos, no_change);
1654 if(ts == AV_NOPTS_VALUE){
1655 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1658 assert(ts != AV_NOPTS_VALUE);
1659 if (target_ts <= ts) {
1660 pos_limit = start_pos - 1;
1664 if (target_ts >= ts) {
1670 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1671 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1673 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1675 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1676 av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1677 pos, ts_min, target_ts, ts_max);
1682 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1683 int64_t pos_min, pos_max;
1687 if (stream_index < 0)
1690 st= s->streams[stream_index];
1693 pos_min = s->data_offset;
1694 pos_max = avio_size(s->pb) - 1;
1696 if (pos < pos_min) pos= pos_min;
1697 else if(pos > pos_max) pos= pos_max;
1699 avio_seek(s->pb, pos, SEEK_SET);
1702 av_update_cur_dts(s, st, ts);
1707 static int seek_frame_generic(AVFormatContext *s,
1708 int stream_index, int64_t timestamp, int flags)
1715 st = s->streams[stream_index];
1717 index = av_index_search_timestamp(st, timestamp, flags);
1719 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1722 if(index < 0 || index==st->nb_index_entries-1){
1726 if(st->nb_index_entries){
1727 assert(st->index_entries);
1728 ie= &st->index_entries[st->nb_index_entries-1];
1729 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1731 av_update_cur_dts(s, st, ie->timestamp);
1733 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1739 ret = av_read_frame(s, &pkt);
1740 }while(ret == AVERROR(EAGAIN));
1743 av_free_packet(&pkt);
1744 if(stream_index == pkt.stream_index){
1745 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1749 index = av_index_search_timestamp(st, timestamp, flags);
1754 ff_read_frame_flush(s);
1755 if (s->iformat->read_seek){
1756 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1759 ie = &st->index_entries[index];
1760 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1762 av_update_cur_dts(s, st, ie->timestamp);
1767 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1772 ff_read_frame_flush(s);
1774 if(flags & AVSEEK_FLAG_BYTE)
1775 return seek_frame_byte(s, stream_index, timestamp, flags);
1777 if(stream_index < 0){
1778 stream_index= av_find_default_stream_index(s);
1779 if(stream_index < 0)
1782 st= s->streams[stream_index];
1783 /* timestamp for default must be expressed in AV_TIME_BASE units */
1784 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1787 /* first, we try the format specific seek */
1788 if (s->iformat->read_seek)
1789 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1796 if(s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH))
1797 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1798 else if (!(s->iformat->flags & AVFMT_NOGENSEARCH))
1799 return seek_frame_generic(s, stream_index, timestamp, flags);
1804 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1806 if(min_ts > ts || max_ts < ts)
1809 ff_read_frame_flush(s);
1811 if (s->iformat->read_seek2)
1812 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1814 if(s->iformat->read_timestamp){
1815 //try to seek via read_timestamp()
1818 //Fallback to old API if new is not implemented but old is
1819 //Note the old has somewat different sematics
1820 if(s->iformat->read_seek || 1)
1821 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1823 // try some generic seek like seek_frame_generic() but with new ts semantics
1826 /*******************************************************/
1829 * Return TRUE if the stream has accurate duration in any stream.
1831 * @return TRUE if the stream has accurate duration for at least one component.
1833 static int has_duration(AVFormatContext *ic)
1838 for(i = 0;i < ic->nb_streams; i++) {
1839 st = ic->streams[i];
1840 if (st->duration != AV_NOPTS_VALUE)
1847 * Estimate the stream timings from the one of each components.
1849 * Also computes the global bitrate if possible.
1851 static void update_stream_timings(AVFormatContext *ic)
1853 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
1854 int64_t duration, duration1;
1858 start_time = INT64_MAX;
1859 start_time_text = INT64_MAX;
1860 end_time = INT64_MIN;
1861 duration = INT64_MIN;
1862 for(i = 0;i < ic->nb_streams; i++) {
1863 st = ic->streams[i];
1864 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1865 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1866 if (st->codec->codec_id == CODEC_ID_DVB_TELETEXT) {
1867 if (start_time1 < start_time_text)
1868 start_time_text = start_time1;
1870 if (start_time1 < start_time)
1871 start_time = start_time1;
1872 if (st->duration != AV_NOPTS_VALUE) {
1873 end_time1 = start_time1
1874 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1875 if (end_time1 > end_time)
1876 end_time = end_time1;
1879 if (st->duration != AV_NOPTS_VALUE) {
1880 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1881 if (duration1 > duration)
1882 duration = duration1;
1885 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
1886 start_time = start_time_text;
1887 if (start_time != INT64_MAX) {
1888 ic->start_time = start_time;
1889 if (end_time != INT64_MIN) {
1890 if (end_time - start_time > duration)
1891 duration = end_time - start_time;
1894 if (duration != INT64_MIN) {
1895 ic->duration = duration;
1896 if (ic->file_size > 0) {
1897 /* compute the bitrate */
1898 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1899 (double)ic->duration;
1904 static void fill_all_stream_timings(AVFormatContext *ic)
1909 update_stream_timings(ic);
1910 for(i = 0;i < ic->nb_streams; i++) {
1911 st = ic->streams[i];
1912 if (st->start_time == AV_NOPTS_VALUE) {
1913 if(ic->start_time != AV_NOPTS_VALUE)
1914 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1915 if(ic->duration != AV_NOPTS_VALUE)
1916 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1921 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1923 int64_t filesize, duration;
1927 /* if bit_rate is already set, we believe it */
1928 if (ic->bit_rate <= 0) {
1930 for(i=0;i<ic->nb_streams;i++) {
1931 st = ic->streams[i];
1932 if (st->codec->bit_rate > 0)
1933 bit_rate += st->codec->bit_rate;
1935 ic->bit_rate = bit_rate;
1938 /* if duration is already set, we believe it */
1939 if (ic->duration == AV_NOPTS_VALUE &&
1940 ic->bit_rate != 0 &&
1941 ic->file_size != 0) {
1942 filesize = ic->file_size;
1944 for(i = 0; i < ic->nb_streams; i++) {
1945 st = ic->streams[i];
1946 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1947 if (st->duration == AV_NOPTS_VALUE)
1948 st->duration = duration;
1954 #define DURATION_MAX_READ_SIZE 250000
1955 #define DURATION_MAX_RETRY 3
1957 /* only usable for MPEG-PS streams */
1958 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1960 AVPacket pkt1, *pkt = &pkt1;
1962 int read_size, i, ret;
1964 int64_t filesize, offset, duration;
1969 /* flush packet queue */
1970 flush_packet_queue(ic);
1972 for (i=0; i<ic->nb_streams; i++) {
1973 st = ic->streams[i];
1974 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1975 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
1978 av_parser_close(st->parser);
1980 av_free_packet(&st->cur_pkt);
1984 /* estimate the end time (duration) */
1985 /* XXX: may need to support wrapping */
1986 filesize = ic->file_size;
1987 end_time = AV_NOPTS_VALUE;
1989 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1993 avio_seek(ic->pb, offset, SEEK_SET);
1996 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2000 ret = av_read_packet(ic, pkt);
2001 }while(ret == AVERROR(EAGAIN));
2004 read_size += pkt->size;
2005 st = ic->streams[pkt->stream_index];
2006 if (pkt->pts != AV_NOPTS_VALUE &&
2007 (st->start_time != AV_NOPTS_VALUE ||
2008 st->first_dts != AV_NOPTS_VALUE)) {
2009 duration = end_time = pkt->pts;
2010 if (st->start_time != AV_NOPTS_VALUE) duration -= st->start_time;
2011 else duration -= st->first_dts;
2013 duration += 1LL<<st->pts_wrap_bits;
2015 if (st->duration == AV_NOPTS_VALUE ||
2016 st->duration < duration)
2017 st->duration = duration;
2020 av_free_packet(pkt);
2022 }while( end_time==AV_NOPTS_VALUE
2023 && filesize > (DURATION_MAX_READ_SIZE<<retry)
2024 && ++retry <= DURATION_MAX_RETRY);
2026 fill_all_stream_timings(ic);
2028 avio_seek(ic->pb, old_offset, SEEK_SET);
2029 for (i=0; i<ic->nb_streams; i++) {
2031 st->cur_dts= st->first_dts;
2032 st->last_IP_pts = AV_NOPTS_VALUE;
2033 st->reference_dts = AV_NOPTS_VALUE;
2037 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2041 /* get the file size, if possible */
2042 if (ic->iformat->flags & AVFMT_NOFILE) {
2045 file_size = avio_size(ic->pb);
2049 ic->file_size = file_size;
2051 if ((!strcmp(ic->iformat->name, "mpeg") ||
2052 !strcmp(ic->iformat->name, "mpegts")) &&
2053 file_size && ic->pb->seekable) {
2054 /* get accurate estimate from the PTSes */
2055 estimate_timings_from_pts(ic, old_offset);
2056 } else if (has_duration(ic)) {
2057 /* at least one component has timings - we use them for all
2059 fill_all_stream_timings(ic);
2061 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2062 /* less precise: use bitrate info */
2063 estimate_timings_from_bit_rate(ic);
2065 update_stream_timings(ic);
2070 AVStream av_unused *st;
2071 for(i = 0;i < ic->nb_streams; i++) {
2072 st = ic->streams[i];
2073 printf("%d: start_time: %0.3f duration: %0.3f\n",
2074 i, (double)st->start_time / AV_TIME_BASE,
2075 (double)st->duration / AV_TIME_BASE);
2077 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2078 (double)ic->start_time / AV_TIME_BASE,
2079 (double)ic->duration / AV_TIME_BASE,
2080 ic->bit_rate / 1000);
2085 static int has_codec_parameters(AVCodecContext *avctx)
2088 switch (avctx->codec_type) {
2089 case AVMEDIA_TYPE_AUDIO:
2090 val = avctx->sample_rate && avctx->channels && avctx->sample_fmt != AV_SAMPLE_FMT_NONE;
2091 if(!avctx->frame_size &&
2092 (avctx->codec_id == CODEC_ID_VORBIS ||
2093 avctx->codec_id == CODEC_ID_AAC ||
2094 avctx->codec_id == CODEC_ID_MP1 ||
2095 avctx->codec_id == CODEC_ID_MP2 ||
2096 avctx->codec_id == CODEC_ID_MP3 ||
2097 avctx->codec_id == CODEC_ID_SPEEX ||
2098 avctx->codec_id == CODEC_ID_CELT))
2101 case AVMEDIA_TYPE_VIDEO:
2102 val = avctx->width && avctx->pix_fmt != PIX_FMT_NONE;
2108 return avctx->codec_id != CODEC_ID_NONE && val != 0;
2111 static int has_decode_delay_been_guessed(AVStream *st)
2113 return st->codec->codec_id != CODEC_ID_H264 ||
2114 st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2117 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2121 int got_picture, data_size, ret=0;
2124 if(!st->codec->codec){
2125 codec = avcodec_find_decoder(st->codec->codec_id);
2128 ret = avcodec_open2(st->codec, codec, options);
2133 if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st) ||
2134 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF)) {
2135 switch(st->codec->codec_type) {
2136 case AVMEDIA_TYPE_VIDEO:
2137 avcodec_get_frame_defaults(&picture);
2138 ret = avcodec_decode_video2(st->codec, &picture,
2139 &got_picture, avpkt);
2141 case AVMEDIA_TYPE_AUDIO:
2142 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2143 samples = av_malloc(data_size);
2146 ret = avcodec_decode_audio3(st->codec, samples,
2158 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2160 while (tags->id != CODEC_ID_NONE) {
2168 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2171 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2172 if(tag == tags[i].tag)
2175 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2176 if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2179 return CODEC_ID_NONE;
2182 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2185 for(i=0; tags && tags[i]; i++){
2186 int tag= ff_codec_get_tag(tags[i], id);
2192 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2195 for(i=0; tags && tags[i]; i++){
2196 enum CodecID id= ff_codec_get_id(tags[i], tag);
2197 if(id!=CODEC_ID_NONE) return id;
2199 return CODEC_ID_NONE;
2202 static void compute_chapters_end(AVFormatContext *s)
2205 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2207 for (i = 0; i < s->nb_chapters; i++)
2208 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2209 AVChapter *ch = s->chapters[i];
2210 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2213 for (j = 0; j < s->nb_chapters; j++) {
2214 AVChapter *ch1 = s->chapters[j];
2215 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2216 if (j != i && next_start > ch->start && next_start < end)
2219 ch->end = (end == INT64_MAX) ? ch->start : end;
2223 static int get_std_framerate(int i){
2224 if(i<60*12) return i*1001;
2225 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2229 * Is the time base unreliable.
2230 * This is a heuristic to balance between quick acceptance of the values in
2231 * the headers vs. some extra checks.
2232 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2233 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2234 * And there are "variable" fps files this needs to detect as well.
2236 static int tb_unreliable(AVCodecContext *c){
2237 if( c->time_base.den >= 101L*c->time_base.num
2238 || c->time_base.den < 5L*c->time_base.num
2239 /* || c->codec_tag == AV_RL32("DIVX")
2240 || c->codec_tag == AV_RL32("XVID")*/
2241 || c->codec_id == CODEC_ID_MPEG2VIDEO
2242 || c->codec_id == CODEC_ID_H264
2248 #if FF_API_FORMAT_PARAMETERS
2249 int av_find_stream_info(AVFormatContext *ic)
2251 return avformat_find_stream_info(ic, NULL);
2255 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2257 int i, count, ret, read_size, j;
2259 AVPacket pkt1, *pkt;
2260 int64_t old_offset = avio_tell(ic->pb);
2261 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2263 for(i=0;i<ic->nb_streams;i++) {
2265 st = ic->streams[i];
2266 if (st->codec->codec_id == CODEC_ID_AAC && st->codec->extradata_size) {
2267 // We need to discard these since they can be plain wrong for
2268 // backwards compatible HE-AAC signaling.
2269 // But when we have no extradata we need to keep them or we can't
2270 // play anything at all.
2271 st->codec->sample_rate = 0;
2272 st->codec->frame_size = 0;
2273 st->codec->channels = 0;
2276 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2277 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2278 /* if(!st->time_base.num)
2280 if(!st->codec->time_base.num)
2281 st->codec->time_base= st->time_base;
2283 //only for the split stuff
2284 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2285 st->parser = av_parser_init(st->codec->codec_id);
2286 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2287 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2290 assert(!st->codec->codec);
2291 codec = avcodec_find_decoder(st->codec->codec_id);
2293 /* Ensure that subtitle_header is properly set. */
2294 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2295 && codec && !st->codec->codec)
2296 avcodec_open2(st->codec, codec, options ? &options[i] : NULL);
2298 //try to just open decoders, in case this is enough to get parameters
2299 if(!has_codec_parameters(st->codec)){
2300 if (codec && !st->codec->codec)
2301 avcodec_open2(st->codec, codec, options ? &options[i] : NULL);
2305 for (i=0; i<ic->nb_streams; i++) {
2306 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2312 if(url_interrupt_cb()){
2314 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2318 /* check if one codec still needs to be handled */
2319 for(i=0;i<ic->nb_streams;i++) {
2320 int fps_analyze_framecount = 20;
2322 st = ic->streams[i];
2323 if (!has_codec_parameters(st->codec))
2325 /* if the timebase is coarse (like the usual millisecond precision
2326 of mkv), we need to analyze more frames to reliably arrive at
2328 if (av_q2d(st->time_base) > 0.0005)
2329 fps_analyze_framecount *= 2;
2330 if (ic->fps_probe_size >= 0)
2331 fps_analyze_framecount = ic->fps_probe_size;
2332 /* variable fps and no guess at the real fps */
2333 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2334 && st->info->duration_count < fps_analyze_framecount
2335 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2337 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2339 if(st->first_dts == AV_NOPTS_VALUE)
2342 if (i == ic->nb_streams) {
2343 /* NOTE: if the format has no header, then we need to read
2344 some packets to get most of the streams, so we cannot
2346 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2347 /* if we found the info for all the codecs, we can stop */
2349 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2353 /* we did not get all the codec info, but we read too much data */
2354 if (read_size >= ic->probesize) {
2356 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2360 /* NOTE: a new stream can be added there if no header in file
2361 (AVFMTCTX_NOHEADER) */
2362 ret = read_frame_internal(ic, &pkt1);
2363 if (ret == AVERROR(EAGAIN))
2368 ret = -1; /* we could not have all the codec parameters before EOF */
2369 for(i=0;i<ic->nb_streams;i++) {
2370 st = ic->streams[i];
2371 if (!has_codec_parameters(st->codec)){
2373 avcodec_string(buf, sizeof(buf), st->codec, 0);
2374 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2382 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2383 if ((ret = av_dup_packet(pkt)) < 0)
2384 goto find_stream_info_err;
2386 read_size += pkt->size;
2388 st = ic->streams[pkt->stream_index];
2389 if (st->codec_info_nb_frames>1) {
2391 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) {
2392 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64"\n", ic->max_analyze_duration, t);
2395 st->info->codec_info_duration += pkt->duration;
2398 int64_t last = st->info->last_dts;
2399 int64_t duration= pkt->dts - last;
2401 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2402 double dur= duration * av_q2d(st->time_base);
2404 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2405 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2406 if (st->info->duration_count < 2)
2407 memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2408 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2409 int framerate= get_std_framerate(i);
2410 int ticks= lrintf(dur*framerate/(1001*12));
2411 double error= dur - ticks*1001*12/(double)framerate;
2412 st->info->duration_error[i] += error*error;
2414 st->info->duration_count++;
2415 // ignore the first 4 values, they might have some random jitter
2416 if (st->info->duration_count > 3)
2417 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2419 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2420 st->info->last_dts = pkt->dts;
2422 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2423 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2425 st->codec->extradata_size= i;
2426 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2427 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2428 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2432 /* if still no information, we try to open the codec and to
2433 decompress the frame. We try to avoid that in most cases as
2434 it takes longer and uses more memory. For MPEG-4, we need to
2435 decompress for QuickTime.
2437 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2438 least one frame of codec data, this makes sure the codec initializes
2439 the channel configuration and does not only trust the values from the container.
2441 try_decode_frame(st, pkt, (options && i < orig_nb_streams )? &options[i] : NULL);
2443 st->codec_info_nb_frames++;
2447 // close codecs which were opened in try_decode_frame()
2448 for(i=0;i<ic->nb_streams;i++) {
2449 st = ic->streams[i];
2450 if(st->codec->codec)
2451 avcodec_close(st->codec);
2453 for(i=0;i<ic->nb_streams;i++) {
2454 st = ic->streams[i];
2455 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2456 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2457 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2458 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2459 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2460 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2461 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2462 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2463 st->codec->codec_tag= tag;
2466 // the check for tb_unreliable() is not completely correct, since this is not about handling
2467 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2468 // ipmovie.c produces.
2469 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)
2470 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);
2471 if (st->info->duration_count && !st->r_frame_rate.num
2472 && tb_unreliable(st->codec) /*&&
2473 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2474 st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2476 double best_error= 2*av_q2d(st->time_base);
2477 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2479 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2480 double error = st->info->duration_error[j] * get_std_framerate(j);
2481 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2482 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2483 if(error < best_error){
2485 num = get_std_framerate(j);
2488 // do not increase frame rate by more than 1 % in order to match a standard rate.
2489 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2490 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2493 if (!st->r_frame_rate.num){
2494 if( st->codec->time_base.den * (int64_t)st->time_base.num
2495 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2496 st->r_frame_rate.num = st->codec->time_base.den;
2497 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2499 st->r_frame_rate.num = st->time_base.den;
2500 st->r_frame_rate.den = st->time_base.num;
2503 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2504 if(!st->codec->bits_per_coded_sample)
2505 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2506 // set stream disposition based on audio service type
2507 switch (st->codec->audio_service_type) {
2508 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2509 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2510 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2511 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2512 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2513 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2514 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2515 st->disposition = AV_DISPOSITION_COMMENT; break;
2516 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2517 st->disposition = AV_DISPOSITION_KARAOKE; break;
2522 estimate_timings(ic, old_offset);
2524 compute_chapters_end(ic);
2527 /* correct DTS for B-frame streams with no timestamps */
2528 for(i=0;i<ic->nb_streams;i++) {
2529 st = ic->streams[i];
2530 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2532 ppktl = &ic->packet_buffer;
2534 if(ppkt1->stream_index != i)
2536 if(ppkt1->pkt->dts < 0)
2538 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2540 ppkt1->pkt->dts -= delta;
2545 st->cur_dts -= delta;
2551 find_stream_info_err:
2552 for (i=0; i < ic->nb_streams; i++)
2553 av_freep(&ic->streams[i]->info);
2557 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2561 for (i = 0; i < ic->nb_programs; i++)
2562 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2563 if (ic->programs[i]->stream_index[j] == s)
2564 return ic->programs[i];
2568 int av_find_best_stream(AVFormatContext *ic,
2569 enum AVMediaType type,
2570 int wanted_stream_nb,
2572 AVCodec **decoder_ret,
2575 int i, nb_streams = ic->nb_streams;
2576 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2577 unsigned *program = NULL;
2578 AVCodec *decoder = NULL, *best_decoder = NULL;
2580 if (related_stream >= 0 && wanted_stream_nb < 0) {
2581 AVProgram *p = find_program_from_stream(ic, related_stream);
2583 program = p->stream_index;
2584 nb_streams = p->nb_stream_indexes;
2587 for (i = 0; i < nb_streams; i++) {
2588 int real_stream_index = program ? program[i] : i;
2589 AVStream *st = ic->streams[real_stream_index];
2590 AVCodecContext *avctx = st->codec;
2591 if (avctx->codec_type != type)
2593 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2595 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2598 decoder = avcodec_find_decoder(st->codec->codec_id);
2601 ret = AVERROR_DECODER_NOT_FOUND;
2605 if (best_count >= st->codec_info_nb_frames)
2607 best_count = st->codec_info_nb_frames;
2608 ret = real_stream_index;
2609 best_decoder = decoder;
2610 if (program && i == nb_streams - 1 && ret < 0) {
2612 nb_streams = ic->nb_streams;
2613 i = 0; /* no related stream found, try again with everything */
2617 *decoder_ret = best_decoder;
2621 /*******************************************************/
2623 int av_read_play(AVFormatContext *s)
2625 if (s->iformat->read_play)
2626 return s->iformat->read_play(s);
2628 return avio_pause(s->pb, 0);
2629 return AVERROR(ENOSYS);
2632 int av_read_pause(AVFormatContext *s)
2634 if (s->iformat->read_pause)
2635 return s->iformat->read_pause(s);
2637 return avio_pause(s->pb, 1);
2638 return AVERROR(ENOSYS);
2641 void av_close_input_stream(AVFormatContext *s)
2643 flush_packet_queue(s);
2644 if (s->iformat->read_close)
2645 s->iformat->read_close(s);
2646 avformat_free_context(s);
2649 void avformat_free_context(AVFormatContext *s)
2655 if (s->iformat && s->iformat->priv_class && s->priv_data)
2656 av_opt_free(s->priv_data);
2658 for(i=0;i<s->nb_streams;i++) {
2659 /* free all data in a stream component */
2662 av_parser_close(st->parser);
2663 av_free_packet(&st->cur_pkt);
2665 av_dict_free(&st->metadata);
2666 av_free(st->index_entries);
2667 av_free(st->codec->extradata);
2668 av_free(st->codec->subtitle_header);
2670 av_free(st->priv_data);
2674 for(i=s->nb_programs-1; i>=0; i--) {
2675 av_dict_free(&s->programs[i]->metadata);
2676 av_freep(&s->programs[i]->stream_index);
2677 av_freep(&s->programs[i]);
2679 av_freep(&s->programs);
2680 av_freep(&s->priv_data);
2681 while(s->nb_chapters--) {
2682 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2683 av_free(s->chapters[s->nb_chapters]);
2685 av_freep(&s->chapters);
2686 av_dict_free(&s->metadata);
2687 av_freep(&s->streams);
2691 void av_close_input_file(AVFormatContext *s)
2693 AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2695 av_close_input_stream(s);
2700 AVStream *av_new_stream(AVFormatContext *s, int id)
2706 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2708 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2711 s->streams = streams;
2713 st = av_mallocz(sizeof(AVStream));
2716 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2721 st->codec = avcodec_alloc_context3(NULL);
2723 /* no default bitrate if decoding */
2724 st->codec->bit_rate = 0;
2726 st->index = s->nb_streams;
2728 st->start_time = AV_NOPTS_VALUE;
2729 st->duration = AV_NOPTS_VALUE;
2730 /* we set the current DTS to 0 so that formats without any timestamps
2731 but durations get some timestamps, formats with some unknown
2732 timestamps have their first few packets buffered and the
2733 timestamps corrected before they are returned to the user */
2735 st->first_dts = AV_NOPTS_VALUE;
2736 st->probe_packets = MAX_PROBE_PACKETS;
2738 /* default pts setting is MPEG-like */
2739 av_set_pts_info(st, 33, 1, 90000);
2740 st->last_IP_pts = AV_NOPTS_VALUE;
2741 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2742 st->pts_buffer[i]= AV_NOPTS_VALUE;
2743 st->reference_dts = AV_NOPTS_VALUE;
2745 st->sample_aspect_ratio = (AVRational){0,1};
2747 s->streams[s->nb_streams++] = st;
2751 AVProgram *av_new_program(AVFormatContext *ac, int id)
2753 AVProgram *program=NULL;
2756 av_dlog(ac, "new_program: id=0x%04x\n", id);
2758 for(i=0; i<ac->nb_programs; i++)
2759 if(ac->programs[i]->id == id)
2760 program = ac->programs[i];
2763 program = av_mallocz(sizeof(AVProgram));
2766 dynarray_add(&ac->programs, &ac->nb_programs, program);
2767 program->discard = AVDISCARD_NONE;
2774 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2776 AVChapter *chapter = NULL;
2779 for(i=0; i<s->nb_chapters; i++)
2780 if(s->chapters[i]->id == id)
2781 chapter = s->chapters[i];
2784 chapter= av_mallocz(sizeof(AVChapter));
2787 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2789 av_dict_set(&chapter->metadata, "title", title, 0);
2791 chapter->time_base= time_base;
2792 chapter->start = start;
2798 /************************************************************/
2799 /* output media file */
2801 #if FF_API_FORMAT_PARAMETERS
2802 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2804 if (s->oformat->priv_data_size > 0) {
2805 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2807 return AVERROR(ENOMEM);
2808 if (s->oformat->priv_class) {
2809 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2810 av_opt_set_defaults(s->priv_data);
2813 s->priv_data = NULL;
2819 int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
2820 const char *format, const char *filename)
2822 AVFormatContext *s = avformat_alloc_context();
2831 oformat = av_guess_format(format, NULL, NULL);
2833 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
2834 ret = AVERROR(EINVAL);
2838 oformat = av_guess_format(NULL, filename, NULL);
2840 ret = AVERROR(EINVAL);
2841 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
2848 s->oformat = oformat;
2849 if (s->oformat->priv_data_size > 0) {
2850 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2853 if (s->oformat->priv_class) {
2854 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2855 av_opt_set_defaults(s->priv_data);
2858 s->priv_data = NULL;
2861 av_strlcpy(s->filename, filename, sizeof(s->filename));
2865 av_log(s, AV_LOG_ERROR, "Out of memory\n");
2866 ret = AVERROR(ENOMEM);
2868 avformat_free_context(s);
2872 #if FF_API_ALLOC_OUTPUT_CONTEXT
2873 AVFormatContext *avformat_alloc_output_context(const char *format,
2874 AVOutputFormat *oformat, const char *filename)
2876 AVFormatContext *avctx;
2877 int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
2878 return ret < 0 ? NULL : avctx;
2882 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2884 const AVCodecTag *avctag;
2886 enum CodecID id = CODEC_ID_NONE;
2887 unsigned int tag = 0;
2890 * Check that tag + id is in the table
2891 * If neither is in the table -> OK
2892 * If tag is in the table with another id -> FAIL
2893 * If id is in the table with another tag -> FAIL unless strict < normal
2895 for (n = 0; s->oformat->codec_tag[n]; n++) {
2896 avctag = s->oformat->codec_tag[n];
2897 while (avctag->id != CODEC_ID_NONE) {
2898 if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2900 if (id == st->codec->codec_id)
2903 if (avctag->id == st->codec->codec_id)
2908 if (id != CODEC_ID_NONE)
2910 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2915 #if FF_API_FORMAT_PARAMETERS
2916 int av_write_header(AVFormatContext *s)
2918 return avformat_write_header(s, NULL);
2922 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2926 AVDictionary *tmp = NULL;
2929 av_dict_copy(&tmp, *options, 0);
2930 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2933 // some sanity checks
2934 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2935 av_log(s, AV_LOG_ERROR, "no streams\n");
2936 ret = AVERROR(EINVAL);
2940 for(i=0;i<s->nb_streams;i++) {
2943 switch (st->codec->codec_type) {
2944 case AVMEDIA_TYPE_AUDIO:
2945 if(st->codec->sample_rate<=0){
2946 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2947 ret = AVERROR(EINVAL);
2950 if(!st->codec->block_align)
2951 st->codec->block_align = st->codec->channels *
2952 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2954 case AVMEDIA_TYPE_VIDEO:
2955 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2956 av_log(s, AV_LOG_ERROR, "time base not set\n");
2957 ret = AVERROR(EINVAL);
2960 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2961 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2962 ret = AVERROR(EINVAL);
2965 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2966 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2967 ret = AVERROR(EINVAL);
2973 if(s->oformat->codec_tag){
2974 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)){
2975 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2976 st->codec->codec_tag= 0;
2978 if(st->codec->codec_tag){
2979 if (!validate_codec_tag(s, st)) {
2981 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2982 av_log(s, AV_LOG_ERROR,
2983 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2984 tagbuf, st->codec->codec_tag, st->codec->codec_id);
2985 ret = AVERROR_INVALIDDATA;
2989 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2992 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2993 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2994 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2997 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2998 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2999 if (!s->priv_data) {
3000 ret = AVERROR(ENOMEM);
3003 if (s->oformat->priv_class) {
3004 *(const AVClass**)s->priv_data= s->oformat->priv_class;
3005 av_opt_set_defaults(s->priv_data);
3006 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3011 /* set muxer identification string */
3012 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
3013 av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
3016 if(s->oformat->write_header){
3017 ret = s->oformat->write_header(s);
3022 /* init PTS generation */
3023 for(i=0;i<s->nb_streams;i++) {
3024 int64_t den = AV_NOPTS_VALUE;
3027 switch (st->codec->codec_type) {
3028 case AVMEDIA_TYPE_AUDIO:
3029 den = (int64_t)st->time_base.num * st->codec->sample_rate;
3031 case AVMEDIA_TYPE_VIDEO:
3032 den = (int64_t)st->time_base.num * st->codec->time_base.den;
3037 if (den != AV_NOPTS_VALUE) {
3039 ret = AVERROR_INVALIDDATA;
3042 frac_init(&st->pts, 0, 0, den);
3047 av_dict_free(options);
3056 //FIXME merge with compute_pkt_fields
3057 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3058 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3059 int num, den, frame_size, i;
3061 av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3062 pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3064 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
3065 return AVERROR(EINVAL);*/
3067 /* duration field */
3068 if (pkt->duration == 0) {
3069 compute_frame_duration(&num, &den, st, NULL, pkt);
3071 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3075 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3078 //XXX/FIXME this is a temporary hack until all encoders output pts
3079 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3081 // pkt->pts= st->cur_dts;
3082 pkt->pts= st->pts.val;
3085 //calculate dts from pts
3086 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3087 st->pts_buffer[0]= pkt->pts;
3088 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3089 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3090 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3091 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3093 pkt->dts= st->pts_buffer[0];
3096 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)){
3097 av_log(s, AV_LOG_ERROR,
3098 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3099 st->index, st->cur_dts, pkt->dts);
3100 return AVERROR(EINVAL);
3102 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3103 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3104 return AVERROR(EINVAL);
3107 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3108 st->cur_dts= pkt->dts;
3109 st->pts.val= pkt->dts;
3112 switch (st->codec->codec_type) {
3113 case AVMEDIA_TYPE_AUDIO:
3114 frame_size = get_audio_frame_size(st->codec, pkt->size);
3116 /* HACK/FIXME, we skip the initial 0 size packets as they are most
3117 likely equal to the encoder delay, but it would be better if we
3118 had the real timestamps from the encoder */
3119 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3120 frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3123 case AVMEDIA_TYPE_VIDEO:
3124 frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3132 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3134 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3136 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3139 ret= s->oformat->write_packet(s, pkt);
3142 s->streams[pkt->stream_index]->nb_frames++;
3146 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3147 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3149 AVPacketList **next_point, *this_pktl;
3151 this_pktl = av_mallocz(sizeof(AVPacketList));
3152 this_pktl->pkt= *pkt;
3153 pkt->destruct= NULL; // do not free original but only the copy
3154 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
3156 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3157 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3159 next_point = &s->packet_buffer;
3162 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3163 while(!compare(s, &(*next_point)->pkt, pkt)){
3164 next_point= &(*next_point)->next;
3168 next_point = &(s->packet_buffer_end->next);
3171 assert(!*next_point);
3173 s->packet_buffer_end= this_pktl;
3176 this_pktl->next= *next_point;
3178 s->streams[pkt->stream_index]->last_in_packet_buffer=
3179 *next_point= this_pktl;
3182 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3184 AVStream *st = s->streams[ pkt ->stream_index];
3185 AVStream *st2= s->streams[ next->stream_index];
3186 int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3190 return pkt->stream_index < next->stream_index;
3194 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3200 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3203 for(i=0; i < s->nb_streams; i++)
3204 stream_count+= !!s->streams[i]->last_in_packet_buffer;
3206 if(stream_count && (s->nb_streams == stream_count || flush)){
3207 pktl= s->packet_buffer;
3210 s->packet_buffer= pktl->next;
3211 if(!s->packet_buffer)
3212 s->packet_buffer_end= NULL;
3214 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3215 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3219 av_init_packet(out);
3225 * Interleave an AVPacket correctly so it can be muxed.
3226 * @param out the interleaved packet will be output here
3227 * @param in the input packet
3228 * @param flush 1 if no further packets are available as input and all
3229 * remaining packets should be output
3230 * @return 1 if a packet was output, 0 if no packet could be output,
3231 * < 0 if an error occurred
3233 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3234 if(s->oformat->interleave_packet)
3235 return s->oformat->interleave_packet(s, out, in, flush);
3237 return av_interleave_packet_per_dts(s, out, in, flush);
3240 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3241 AVStream *st= s->streams[ pkt->stream_index];
3244 //FIXME/XXX/HACK drop zero sized packets
3245 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3248 av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3249 pkt->size, pkt->dts, pkt->pts);
3250 if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3253 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3254 return AVERROR(EINVAL);
3258 int ret= interleave_packet(s, &opkt, pkt, 0);
3259 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3262 ret= s->oformat->write_packet(s, &opkt);
3264 s->streams[opkt.stream_index]->nb_frames++;
3266 av_free_packet(&opkt);
3271 if(url_ferror(s->pb))
3272 return url_ferror(s->pb);
3276 int av_write_trailer(AVFormatContext *s)
3282 ret= interleave_packet(s, &pkt, NULL, 1);
3283 if(ret<0) //FIXME cleanup needed for ret<0 ?
3288 ret= s->oformat->write_packet(s, &pkt);
3290 s->streams[pkt.stream_index]->nb_frames++;
3292 av_free_packet(&pkt);
3296 if(url_ferror(s->pb))
3300 if(s->oformat->write_trailer)
3301 ret = s->oformat->write_trailer(s);
3304 ret=url_ferror(s->pb);
3305 for(i=0;i<s->nb_streams;i++) {
3306 av_freep(&s->streams[i]->priv_data);
3307 av_freep(&s->streams[i]->index_entries);
3309 if (s->iformat && s->iformat->priv_class)
3310 av_opt_free(s->priv_data);
3311 av_freep(&s->priv_data);
3315 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
3316 int64_t *dts, int64_t *wall)
3318 if (!s->oformat || !s->oformat->get_output_timestamp)
3319 return AVERROR(ENOSYS);
3320 s->oformat->get_output_timestamp(s, stream, dts, wall);
3324 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3327 AVProgram *program=NULL;
3330 if (idx >= ac->nb_streams) {
3331 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3335 for(i=0; i<ac->nb_programs; i++){
3336 if(ac->programs[i]->id != progid)
3338 program = ac->programs[i];
3339 for(j=0; j<program->nb_stream_indexes; j++)
3340 if(program->stream_index[j] == idx)
3343 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3346 program->stream_index = tmp;
3347 program->stream_index[program->nb_stream_indexes++] = idx;
3352 static void print_fps(double d, const char *postfix){
3353 uint64_t v= lrintf(d*100);
3354 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3355 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3356 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3359 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3361 if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3362 AVDictionaryEntry *tag=NULL;
3364 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3365 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3366 if(strcmp("language", tag->key)){
3369 av_strlcpy(tmp, tag->value, sizeof(tmp));
3370 for(i=0; i<strlen(tmp); i++) if(tmp[i]==0xd) tmp[i]=' ';
3371 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tmp);
3377 /* "user interface" functions */
3378 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3381 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3382 AVStream *st = ic->streams[i];
3383 int g = av_gcd(st->time_base.num, st->time_base.den);
3384 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3385 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3386 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
3387 /* the pid is an important information, so we display it */
3388 /* XXX: add a generic system */
3389 if (flags & AVFMT_SHOW_IDS)
3390 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3392 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3393 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3394 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3395 if (st->sample_aspect_ratio.num && // default
3396 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3397 AVRational display_aspect_ratio;
3398 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3399 st->codec->width*st->sample_aspect_ratio.num,
3400 st->codec->height*st->sample_aspect_ratio.den,
3402 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3403 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3404 display_aspect_ratio.num, display_aspect_ratio.den);
3406 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3407 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3408 print_fps(av_q2d(st->avg_frame_rate), "fps");
3409 if(st->r_frame_rate.den && st->r_frame_rate.num)
3410 print_fps(av_q2d(st->r_frame_rate), "tbr");
3411 if(st->time_base.den && st->time_base.num)
3412 print_fps(1/av_q2d(st->time_base), "tbn");
3413 if(st->codec->time_base.den && st->codec->time_base.num)
3414 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3416 if (st->disposition & AV_DISPOSITION_DEFAULT)
3417 av_log(NULL, AV_LOG_INFO, " (default)");
3418 if (st->disposition & AV_DISPOSITION_DUB)
3419 av_log(NULL, AV_LOG_INFO, " (dub)");
3420 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3421 av_log(NULL, AV_LOG_INFO, " (original)");
3422 if (st->disposition & AV_DISPOSITION_COMMENT)
3423 av_log(NULL, AV_LOG_INFO, " (comment)");
3424 if (st->disposition & AV_DISPOSITION_LYRICS)
3425 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3426 if (st->disposition & AV_DISPOSITION_KARAOKE)
3427 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3428 if (st->disposition & AV_DISPOSITION_FORCED)
3429 av_log(NULL, AV_LOG_INFO, " (forced)");
3430 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3431 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3432 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3433 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3434 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3435 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3436 av_log(NULL, AV_LOG_INFO, "\n");
3437 dump_metadata(NULL, st->metadata, " ");
3440 #if FF_API_DUMP_FORMAT
3441 void dump_format(AVFormatContext *ic,
3446 av_dump_format(ic, index, url, is_output);
3450 void av_dump_format(AVFormatContext *ic,
3456 uint8_t *printed = av_mallocz(ic->nb_streams);
3457 if (ic->nb_streams && !printed)
3460 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3461 is_output ? "Output" : "Input",
3463 is_output ? ic->oformat->name : ic->iformat->name,
3464 is_output ? "to" : "from", url);
3465 dump_metadata(NULL, ic->metadata, " ");
3467 av_log(NULL, AV_LOG_INFO, " Duration: ");
3468 if (ic->duration != AV_NOPTS_VALUE) {
3469 int hours, mins, secs, us;
3470 secs = ic->duration / AV_TIME_BASE;
3471 us = ic->duration % AV_TIME_BASE;
3476 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3477 (100 * us) / AV_TIME_BASE);
3479 av_log(NULL, AV_LOG_INFO, "N/A");
3481 if (ic->start_time != AV_NOPTS_VALUE) {
3483 av_log(NULL, AV_LOG_INFO, ", start: ");
3484 secs = ic->start_time / AV_TIME_BASE;
3485 us = abs(ic->start_time % AV_TIME_BASE);
3486 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3487 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3489 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3491 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3493 av_log(NULL, AV_LOG_INFO, "N/A");
3495 av_log(NULL, AV_LOG_INFO, "\n");
3497 for (i = 0; i < ic->nb_chapters; i++) {
3498 AVChapter *ch = ic->chapters[i];
3499 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3500 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3501 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3503 dump_metadata(NULL, ch->metadata, " ");
3505 if(ic->nb_programs) {
3506 int j, k, total = 0;
3507 for(j=0; j<ic->nb_programs; j++) {
3508 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3510 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3511 name ? name->value : "");
3512 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3513 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3514 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3515 printed[ic->programs[j]->stream_index[k]] = 1;
3517 total += ic->programs[j]->nb_stream_indexes;
3519 if (total < ic->nb_streams)
3520 av_log(NULL, AV_LOG_INFO, " No Program\n");
3522 for(i=0;i<ic->nb_streams;i++)
3524 dump_stream_format(ic, i, index, is_output);
3529 int64_t av_gettime(void)
3532 gettimeofday(&tv,NULL);
3533 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3536 uint64_t ff_ntp_time(void)
3538 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3541 #if FF_API_PARSE_DATE
3542 #include "libavutil/parseutils.h"
3544 int64_t parse_date(const char *timestr, int duration)
3547 av_parse_time(&timeval, timestr, duration);
3552 #if FF_API_FIND_INFO_TAG
3553 #include "libavutil/parseutils.h"
3555 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3557 return av_find_info_tag(arg, arg_size, tag1, info);
3561 int av_get_frame_filename(char *buf, int buf_size,
3562 const char *path, int number)
3565 char *q, buf1[20], c;
3566 int nd, len, percentd_found;
3578 while (isdigit(*p)) {
3579 nd = nd * 10 + *p++ - '0';
3582 } while (isdigit(c));
3591 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3593 if ((q - buf + len) > buf_size - 1)
3595 memcpy(q, buf1, len);
3603 if ((q - buf) < buf_size - 1)
3607 if (!percentd_found)
3616 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3620 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3622 for(i=0;i<size;i+=16) {
3629 PRINT(" %02x", buf[i+j]);
3634 for(j=0;j<len;j++) {
3636 if (c < ' ' || c > '~')
3645 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3647 hex_dump_internal(NULL, f, 0, buf, size);
3650 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3652 hex_dump_internal(avcl, NULL, level, buf, size);
3655 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3658 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3659 PRINT("stream #%d:\n", pkt->stream_index);
3660 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3661 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3662 /* DTS is _always_ valid after av_read_frame() */
3664 if (pkt->dts == AV_NOPTS_VALUE)
3667 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3668 /* PTS may not be known if B-frames are present. */
3670 if (pkt->pts == AV_NOPTS_VALUE)
3673 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3675 PRINT(" size=%d\n", pkt->size);
3678 av_hex_dump(f, pkt->data, pkt->size);
3682 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3684 AVRational tb = { 1, AV_TIME_BASE };
3685 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3689 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3691 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3695 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3697 AVRational tb = { 1, AV_TIME_BASE };
3698 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3702 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3705 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3708 void av_url_split(char *proto, int proto_size,
3709 char *authorization, int authorization_size,
3710 char *hostname, int hostname_size,
3712 char *path, int path_size,
3715 const char *p, *ls, *at, *col, *brk;
3717 if (port_ptr) *port_ptr = -1;
3718 if (proto_size > 0) proto[0] = 0;
3719 if (authorization_size > 0) authorization[0] = 0;
3720 if (hostname_size > 0) hostname[0] = 0;
3721 if (path_size > 0) path[0] = 0;
3723 /* parse protocol */
3724 if ((p = strchr(url, ':'))) {
3725 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3730 /* no protocol means plain filename */
3731 av_strlcpy(path, url, path_size);
3735 /* separate path from hostname */
3736 ls = strchr(p, '/');
3738 ls = strchr(p, '?');
3740 av_strlcpy(path, ls, path_size);
3742 ls = &p[strlen(p)]; // XXX
3744 /* the rest is hostname, use that to parse auth/port */
3746 /* authorization (user[:pass]@hostname) */
3747 if ((at = strchr(p, '@')) && at < ls) {
3748 av_strlcpy(authorization, p,
3749 FFMIN(authorization_size, at + 1 - p));
3750 p = at + 1; /* skip '@' */
3753 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3755 av_strlcpy(hostname, p + 1,
3756 FFMIN(hostname_size, brk - p));
3757 if (brk[1] == ':' && port_ptr)
3758 *port_ptr = atoi(brk + 2);
3759 } else if ((col = strchr(p, ':')) && col < ls) {
3760 av_strlcpy(hostname, p,
3761 FFMIN(col + 1 - p, hostname_size));
3762 if (port_ptr) *port_ptr = atoi(col + 1);
3764 av_strlcpy(hostname, p,
3765 FFMIN(ls + 1 - p, hostname_size));
3769 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3772 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3775 'C', 'D', 'E', 'F' };
3776 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3779 'c', 'd', 'e', 'f' };
3780 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3782 for(i = 0; i < s; i++) {
3783 buff[i * 2] = hex_table[src[i] >> 4];
3784 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3790 int ff_hex_to_data(uint8_t *data, const char *p)
3797 p += strspn(p, SPACE_CHARS);
3800 c = toupper((unsigned char) *p++);
3801 if (c >= '0' && c <= '9')
3803 else if (c >= 'A' && c <= 'F')
3818 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3819 unsigned int pts_num, unsigned int pts_den)
3822 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3823 if(new_tb.num != pts_num)
3824 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3826 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3828 if(new_tb.num <= 0 || new_tb.den <= 0) {
3829 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3832 s->time_base = new_tb;
3833 s->pts_wrap_bits = pts_wrap_bits;
3836 int ff_url_join(char *str, int size, const char *proto,
3837 const char *authorization, const char *hostname,
3838 int port, const char *fmt, ...)
3841 struct addrinfo hints, *ai;
3846 av_strlcatf(str, size, "%s://", proto);
3847 if (authorization && authorization[0])
3848 av_strlcatf(str, size, "%s@", authorization);
3849 #if CONFIG_NETWORK && defined(AF_INET6)
3850 /* Determine if hostname is a numerical IPv6 address,
3851 * properly escape it within [] in that case. */
3852 memset(&hints, 0, sizeof(hints));
3853 hints.ai_flags = AI_NUMERICHOST;
3854 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3855 if (ai->ai_family == AF_INET6) {
3856 av_strlcat(str, "[", size);
3857 av_strlcat(str, hostname, size);
3858 av_strlcat(str, "]", size);
3860 av_strlcat(str, hostname, size);
3865 /* Not an IPv6 address, just output the plain string. */
3866 av_strlcat(str, hostname, size);
3869 av_strlcatf(str, size, ":%d", port);
3872 int len = strlen(str);
3875 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3881 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3882 AVFormatContext *src)
3887 local_pkt.stream_index = dst_stream;
3888 if (pkt->pts != AV_NOPTS_VALUE)
3889 local_pkt.pts = av_rescale_q(pkt->pts,
3890 src->streams[pkt->stream_index]->time_base,
3891 dst->streams[dst_stream]->time_base);
3892 if (pkt->dts != AV_NOPTS_VALUE)
3893 local_pkt.dts = av_rescale_q(pkt->dts,
3894 src->streams[pkt->stream_index]->time_base,
3895 dst->streams[dst_stream]->time_base);
3896 return av_write_frame(dst, &local_pkt);
3899 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3902 const char *ptr = str;
3904 /* Parse key=value pairs. */
3907 char *dest = NULL, *dest_end;
3908 int key_len, dest_len = 0;
3910 /* Skip whitespace and potential commas. */
3911 while (*ptr && (isspace(*ptr) || *ptr == ','))
3918 if (!(ptr = strchr(key, '=')))
3921 key_len = ptr - key;
3923 callback_get_buf(context, key, key_len, &dest, &dest_len);
3924 dest_end = dest + dest_len - 1;
3928 while (*ptr && *ptr != '\"') {
3932 if (dest && dest < dest_end)
3936 if (dest && dest < dest_end)
3944 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3945 if (dest && dest < dest_end)
3953 int ff_find_stream_index(AVFormatContext *s, int id)
3956 for (i = 0; i < s->nb_streams; i++) {
3957 if (s->streams[i]->id == id)
3963 void ff_make_absolute_url(char *buf, int size, const char *base,
3967 /* Absolute path, relative to the current server */
3968 if (base && strstr(base, "://") && rel[0] == '/') {
3970 av_strlcpy(buf, base, size);
3971 sep = strstr(buf, "://");
3974 sep = strchr(sep, '/');
3978 av_strlcat(buf, rel, size);
3981 /* If rel actually is an absolute url, just copy it */
3982 if (!base || strstr(rel, "://") || rel[0] == '/') {
3983 av_strlcpy(buf, rel, size);
3987 av_strlcpy(buf, base, size);
3988 /* Remove the file name from the base url */
3989 sep = strrchr(buf, '/');
3994 while (av_strstart(rel, "../", NULL) && sep) {
3995 /* Remove the path delimiter at the end */
3997 sep = strrchr(buf, '/');
3998 /* If the next directory name to pop off is "..", break here */
3999 if (!strcmp(sep ? &sep[1] : buf, "..")) {
4000 /* Readd the slash we just removed */
4001 av_strlcat(buf, "/", size);
4004 /* Cut off the directory name */
4011 av_strlcat(buf, rel, size);
4014 int64_t ff_iso8601_to_unix_time(const char *datestr)
4017 struct tm time = {0};
4018 strptime(datestr, "%Y - %m - %dT%T", &time);
4019 return mktime(&time);
4021 av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
4022 "the date string.\n");