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;
526 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
527 int 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_DISCARD_CORRUPT) &&
742 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
743 av_log(s, AV_LOG_WARNING,
744 "Dropped corrupted packet (stream = %d)\n",
749 if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
750 av_packet_merge_side_data(pkt);
752 st= s->streams[pkt->stream_index];
754 switch(st->codec->codec_type){
755 case AVMEDIA_TYPE_VIDEO:
756 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
758 case AVMEDIA_TYPE_AUDIO:
759 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
761 case AVMEDIA_TYPE_SUBTITLE:
762 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
766 if(!pktl && st->request_probe <= 0)
769 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
770 s->raw_packet_buffer_remaining_size -= pkt->size;
772 if(st->request_probe>0){
773 AVProbeData *pd = &st->probe_data;
775 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
778 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
779 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
780 pd->buf_size += pkt->size;
781 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
783 end= s->raw_packet_buffer_remaining_size <= 0
784 || st->probe_packets<=0;
786 if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
787 int score= set_codec_from_probe_data(s, st, pd);
788 if( (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
792 st->request_probe= -1;
793 if(st->codec->codec_id != CODEC_ID_NONE){
794 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
796 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
803 /**********************************************************/
806 * Get the number of samples of an audio frame. Return -1 on error.
808 static int get_audio_frame_size(AVCodecContext *enc, int size)
812 if(enc->codec_id == CODEC_ID_VORBIS)
815 if (enc->frame_size <= 1) {
816 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
818 if (bits_per_sample) {
819 if (enc->channels == 0)
821 frame_size = (size << 3) / (bits_per_sample * enc->channels);
823 /* used for example by ADPCM codecs */
824 if (enc->bit_rate == 0)
826 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
829 frame_size = enc->frame_size;
836 * Return the frame duration in seconds. Return 0 if not available.
838 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
839 AVCodecParserContext *pc, AVPacket *pkt)
845 switch(st->codec->codec_type) {
846 case AVMEDIA_TYPE_VIDEO:
847 if(st->time_base.num*1000LL > st->time_base.den){
848 *pnum = st->time_base.num;
849 *pden = st->time_base.den;
850 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
851 *pnum = st->codec->time_base.num;
852 *pden = st->codec->time_base.den;
853 if (pc && pc->repeat_pict) {
854 *pnum = (*pnum) * (1 + pc->repeat_pict);
856 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
857 //Thus if we have no parser in such case leave duration undefined.
858 if(st->codec->ticks_per_frame>1 && !pc){
863 case AVMEDIA_TYPE_AUDIO:
864 frame_size = get_audio_frame_size(st->codec, pkt->size);
865 if (frame_size <= 0 || st->codec->sample_rate <= 0)
868 *pden = st->codec->sample_rate;
875 static int is_intra_only(AVCodecContext *enc){
876 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
878 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
879 switch(enc->codec_id){
881 case CODEC_ID_MJPEGB:
883 case CODEC_ID_RAWVIDEO:
884 case CODEC_ID_DVVIDEO:
885 case CODEC_ID_HUFFYUV:
886 case CODEC_ID_FFVHUFF:
891 case CODEC_ID_JPEG2000:
899 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
900 int64_t dts, int64_t pts)
902 AVStream *st= s->streams[stream_index];
903 AVPacketList *pktl= s->packet_buffer;
905 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
908 st->first_dts= dts - st->cur_dts;
911 for(; pktl; pktl= pktl->next){
912 if(pktl->pkt.stream_index != stream_index)
914 //FIXME think more about this check
915 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
916 pktl->pkt.pts += st->first_dts;
918 if(pktl->pkt.dts != AV_NOPTS_VALUE)
919 pktl->pkt.dts += st->first_dts;
921 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
922 st->start_time= pktl->pkt.pts;
924 if (st->start_time == AV_NOPTS_VALUE)
925 st->start_time = pts;
928 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
930 AVPacketList *pktl= s->packet_buffer;
933 if(st->first_dts != AV_NOPTS_VALUE){
934 cur_dts= st->first_dts;
935 for(; pktl; pktl= pktl->next){
936 if(pktl->pkt.stream_index == pkt->stream_index){
937 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
939 cur_dts -= pkt->duration;
942 pktl= s->packet_buffer;
943 st->first_dts = cur_dts;
944 }else if(st->cur_dts)
947 for(; pktl; pktl= pktl->next){
948 if(pktl->pkt.stream_index != pkt->stream_index)
950 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
951 && !pktl->pkt.duration){
952 pktl->pkt.dts= cur_dts;
953 if(!st->codec->has_b_frames)
954 pktl->pkt.pts= cur_dts;
955 cur_dts += pkt->duration;
956 pktl->pkt.duration= pkt->duration;
960 if(st->first_dts == AV_NOPTS_VALUE)
961 st->cur_dts= cur_dts;
964 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
965 AVCodecParserContext *pc, AVPacket *pkt)
967 int num, den, presentation_delayed, delay, i;
970 if (s->flags & AVFMT_FLAG_NOFILLIN)
973 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
974 pkt->dts= AV_NOPTS_VALUE;
976 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
977 //FIXME Set low_delay = 0 when has_b_frames = 1
978 st->codec->has_b_frames = 1;
980 /* do we have a video B-frame ? */
981 delay= st->codec->has_b_frames;
982 presentation_delayed = 0;
984 // ignore delay caused by frame threading so that the mpeg2-without-dts
985 // warning will not trigger
986 if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
987 delay -= st->codec->thread_count-1;
989 /* XXX: need has_b_frame, but cannot get it if the codec is
992 pc && pc->pict_type != AV_PICTURE_TYPE_B)
993 presentation_delayed = 1;
995 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
996 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
997 pkt->dts -= 1LL<<st->pts_wrap_bits;
1000 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
1001 // we take the conservative approach and discard both
1002 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
1003 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
1004 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
1005 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
1008 if (pkt->duration == 0) {
1009 compute_frame_duration(&num, &den, st, pc, pkt);
1011 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1013 if(pkt->duration != 0 && s->packet_buffer)
1014 update_initial_durations(s, st, pkt);
1018 /* correct timestamps with byte offset if demuxers only have timestamps
1019 on packet boundaries */
1020 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1021 /* this will estimate bitrate based on this frame's duration and size */
1022 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1023 if(pkt->pts != AV_NOPTS_VALUE)
1025 if(pkt->dts != AV_NOPTS_VALUE)
1029 if (pc && pc->dts_sync_point >= 0) {
1030 // we have synchronization info from the parser
1031 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1033 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1034 if (pkt->dts != AV_NOPTS_VALUE) {
1035 // got DTS from the stream, update reference timestamp
1036 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1037 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1038 } else if (st->reference_dts != AV_NOPTS_VALUE) {
1039 // compute DTS based on reference timestamp
1040 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1041 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1043 if (pc->dts_sync_point > 0)
1044 st->reference_dts = pkt->dts; // new reference
1048 /* This may be redundant, but it should not hurt. */
1049 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1050 presentation_delayed = 1;
1052 // 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);
1053 /* interpolate PTS and DTS if they are not present */
1054 //We skip H264 currently because delay and has_b_frames are not reliably set
1055 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1056 if (presentation_delayed) {
1057 /* DTS = decompression timestamp */
1058 /* PTS = presentation timestamp */
1059 if (pkt->dts == AV_NOPTS_VALUE)
1060 pkt->dts = st->last_IP_pts;
1061 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1062 if (pkt->dts == AV_NOPTS_VALUE)
1063 pkt->dts = st->cur_dts;
1065 /* this is tricky: the dts must be incremented by the duration
1066 of the frame we are displaying, i.e. the last I- or P-frame */
1067 if (st->last_IP_duration == 0)
1068 st->last_IP_duration = pkt->duration;
1069 if(pkt->dts != AV_NOPTS_VALUE)
1070 st->cur_dts = pkt->dts + st->last_IP_duration;
1071 st->last_IP_duration = pkt->duration;
1072 st->last_IP_pts= pkt->pts;
1073 /* cannot compute PTS if not present (we can compute it only
1074 by knowing the future */
1075 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1076 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1077 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1078 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1079 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1080 pkt->pts += pkt->duration;
1081 // 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);
1085 /* presentation is not delayed : PTS and DTS are the same */
1086 if(pkt->pts == AV_NOPTS_VALUE)
1087 pkt->pts = pkt->dts;
1088 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1089 if(pkt->pts == AV_NOPTS_VALUE)
1090 pkt->pts = st->cur_dts;
1091 pkt->dts = pkt->pts;
1092 if(pkt->pts != AV_NOPTS_VALUE)
1093 st->cur_dts = pkt->pts + pkt->duration;
1097 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1098 st->pts_buffer[0]= pkt->pts;
1099 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1100 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1101 if(pkt->dts == AV_NOPTS_VALUE)
1102 pkt->dts= st->pts_buffer[0];
1103 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1104 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1106 if(pkt->dts > st->cur_dts)
1107 st->cur_dts = pkt->dts;
1110 // 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);
1113 if(is_intra_only(st->codec))
1114 pkt->flags |= AV_PKT_FLAG_KEY;
1117 /* keyframe computation */
1118 if (pc->key_frame == 1)
1119 pkt->flags |= AV_PKT_FLAG_KEY;
1120 else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
1121 pkt->flags |= AV_PKT_FLAG_KEY;
1124 pkt->convergence_duration = pc->convergence_duration;
1128 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1133 av_init_packet(pkt);
1136 /* select current input stream component */
1139 if (!st->need_parsing || !st->parser) {
1140 /* no parsing needed: we just output the packet as is */
1141 /* raw data support */
1142 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1143 compute_pkt_fields(s, st, NULL, pkt);
1145 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1146 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1147 ff_reduce_index(s, st->index);
1148 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1151 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1152 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1153 st->cur_ptr, st->cur_len,
1154 st->cur_pkt.pts, st->cur_pkt.dts,
1156 st->cur_pkt.pts = AV_NOPTS_VALUE;
1157 st->cur_pkt.dts = AV_NOPTS_VALUE;
1158 /* increment read pointer */
1162 /* return packet if any */
1166 pkt->stream_index = st->index;
1167 pkt->pts = st->parser->pts;
1168 pkt->dts = st->parser->dts;
1169 pkt->pos = st->parser->pos;
1170 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1172 pkt->destruct= st->cur_pkt.destruct;
1173 st->cur_pkt.destruct= NULL;
1174 st->cur_pkt.data = NULL;
1175 assert(st->cur_len == 0);
1177 pkt->destruct = NULL;
1179 compute_pkt_fields(s, st, st->parser, pkt);
1181 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1182 int64_t pos= (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->pos : st->parser->frame_offset;
1183 ff_reduce_index(s, st->index);
1184 av_add_index_entry(st, pos, pkt->dts,
1185 0, 0, AVINDEX_KEYFRAME);
1192 av_free_packet(&st->cur_pkt);
1197 /* read next packet */
1198 ret = av_read_packet(s, &cur_pkt);
1200 if (ret == AVERROR(EAGAIN))
1202 /* return the last frames, if any */
1203 for(i = 0; i < s->nb_streams; i++) {
1205 if (st->parser && st->need_parsing) {
1206 av_parser_parse2(st->parser, st->codec,
1207 &pkt->data, &pkt->size,
1209 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1215 /* no more packets: really terminate parsing */
1218 st = s->streams[cur_pkt.stream_index];
1219 st->cur_pkt= cur_pkt;
1221 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1222 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1223 st->cur_pkt.pts < st->cur_pkt.dts){
1224 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1225 st->cur_pkt.stream_index,
1229 // av_free_packet(&st->cur_pkt);
1233 if(s->debug & FF_FDEBUG_TS)
1234 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1235 st->cur_pkt.stream_index,
1239 st->cur_pkt.duration,
1243 st->cur_ptr = st->cur_pkt.data;
1244 st->cur_len = st->cur_pkt.size;
1245 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1246 st->parser = av_parser_init(st->codec->codec_id);
1248 /* no parser available: just output the raw packets */
1249 st->need_parsing = AVSTREAM_PARSE_NONE;
1250 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1251 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1252 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1253 st->parser->flags |= PARSER_FLAG_ONCE;
1258 if(s->debug & FF_FDEBUG_TS)
1259 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1270 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1274 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1277 pktl = s->packet_buffer;
1279 AVPacket *next_pkt= &pktl->pkt;
1281 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1282 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1283 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1284 if( pktl->pkt.stream_index == next_pkt->stream_index
1285 && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1286 && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1287 next_pkt->pts= pktl->pkt.dts;
1291 pktl = s->packet_buffer;
1294 if( next_pkt->pts != AV_NOPTS_VALUE
1295 || next_pkt->dts == AV_NOPTS_VALUE
1297 /* read packet from packet buffer, if there is data */
1299 s->packet_buffer = pktl->next;
1305 int ret= read_frame_internal(s, pkt);
1307 if(pktl && ret != AVERROR(EAGAIN)){
1314 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1315 &s->packet_buffer_end)) < 0)
1316 return AVERROR(ENOMEM);
1318 assert(!s->packet_buffer);
1319 return read_frame_internal(s, pkt);
1324 /* XXX: suppress the packet queue */
1325 static void flush_packet_queue(AVFormatContext *s)
1330 pktl = s->packet_buffer;
1333 s->packet_buffer = pktl->next;
1334 av_free_packet(&pktl->pkt);
1337 while(s->raw_packet_buffer){
1338 pktl = s->raw_packet_buffer;
1339 s->raw_packet_buffer = pktl->next;
1340 av_free_packet(&pktl->pkt);
1343 s->packet_buffer_end=
1344 s->raw_packet_buffer_end= NULL;
1345 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1348 /*******************************************************/
1351 int av_find_default_stream_index(AVFormatContext *s)
1353 int first_audio_index = -1;
1357 if (s->nb_streams <= 0)
1359 for(i = 0; i < s->nb_streams; i++) {
1361 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1364 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1365 first_audio_index = i;
1367 return first_audio_index >= 0 ? first_audio_index : 0;
1371 * Flush the frame reader.
1373 void ff_read_frame_flush(AVFormatContext *s)
1378 flush_packet_queue(s);
1382 /* for each stream, reset read state */
1383 for(i = 0; i < s->nb_streams; i++) {
1387 av_parser_close(st->parser);
1389 av_free_packet(&st->cur_pkt);
1391 st->last_IP_pts = AV_NOPTS_VALUE;
1392 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1393 st->reference_dts = AV_NOPTS_VALUE;
1398 st->probe_packets = MAX_PROBE_PACKETS;
1400 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1401 st->pts_buffer[j]= AV_NOPTS_VALUE;
1405 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1408 for(i = 0; i < s->nb_streams; i++) {
1409 AVStream *st = s->streams[i];
1411 st->cur_dts = av_rescale(timestamp,
1412 st->time_base.den * (int64_t)ref_st->time_base.num,
1413 st->time_base.num * (int64_t)ref_st->time_base.den);
1417 void ff_reduce_index(AVFormatContext *s, int stream_index)
1419 AVStream *st= s->streams[stream_index];
1420 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1422 if((unsigned)st->nb_index_entries >= max_entries){
1424 for(i=0; 2*i<st->nb_index_entries; i++)
1425 st->index_entries[i]= st->index_entries[2*i];
1426 st->nb_index_entries= i;
1430 int ff_add_index_entry(AVIndexEntry **index_entries,
1431 int *nb_index_entries,
1432 unsigned int *index_entries_allocated_size,
1433 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1435 AVIndexEntry *entries, *ie;
1438 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1441 entries = av_fast_realloc(*index_entries,
1442 index_entries_allocated_size,
1443 (*nb_index_entries + 1) *
1444 sizeof(AVIndexEntry));
1448 *index_entries= entries;
1450 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1453 index= (*nb_index_entries)++;
1454 ie= &entries[index];
1455 assert(index==0 || ie[-1].timestamp < timestamp);
1457 ie= &entries[index];
1458 if(ie->timestamp != timestamp){
1459 if(ie->timestamp <= timestamp)
1461 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1462 (*nb_index_entries)++;
1463 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1464 distance= ie->min_distance;
1468 ie->timestamp = timestamp;
1469 ie->min_distance= distance;
1476 int av_add_index_entry(AVStream *st,
1477 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1479 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1480 &st->index_entries_allocated_size, pos,
1481 timestamp, size, distance, flags);
1484 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1485 int64_t wanted_timestamp, int flags)
1493 //optimize appending index entries at the end
1494 if(b && entries[b-1].timestamp < wanted_timestamp)
1499 timestamp = entries[m].timestamp;
1500 if(timestamp >= wanted_timestamp)
1502 if(timestamp <= wanted_timestamp)
1505 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1507 if(!(flags & AVSEEK_FLAG_ANY)){
1508 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1509 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1518 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1521 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1522 wanted_timestamp, flags);
1525 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1526 AVInputFormat *avif= s->iformat;
1527 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1528 int64_t ts_min, ts_max, ts;
1533 if (stream_index < 0)
1536 av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1539 ts_min= AV_NOPTS_VALUE;
1540 pos_limit= -1; //gcc falsely says it may be uninitialized
1542 st= s->streams[stream_index];
1543 if(st->index_entries){
1546 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()
1547 index= FFMAX(index, 0);
1548 e= &st->index_entries[index];
1550 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1552 ts_min= e->timestamp;
1553 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1559 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1560 assert(index < st->nb_index_entries);
1562 e= &st->index_entries[index];
1563 assert(e->timestamp >= target_ts);
1565 ts_max= e->timestamp;
1566 pos_limit= pos_max - e->min_distance;
1567 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1568 pos_max,pos_limit, ts_max);
1572 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1577 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1580 av_update_cur_dts(s, st, ts);
1585 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 )){
1587 int64_t start_pos, filesize;
1590 av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1592 if(ts_min == AV_NOPTS_VALUE){
1593 pos_min = s->data_offset;
1594 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1595 if (ts_min == AV_NOPTS_VALUE)
1599 if(ts_max == AV_NOPTS_VALUE){
1601 filesize = avio_size(s->pb);
1602 pos_max = filesize - 1;
1605 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1607 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1608 if (ts_max == AV_NOPTS_VALUE)
1612 int64_t tmp_pos= pos_max + 1;
1613 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1614 if(tmp_ts == AV_NOPTS_VALUE)
1618 if(tmp_pos >= filesize)
1624 if(ts_min > ts_max){
1626 }else if(ts_min == ts_max){
1631 while (pos_min < pos_limit) {
1632 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1633 pos_min, pos_max, ts_min, ts_max);
1634 assert(pos_limit <= pos_max);
1637 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1638 // interpolate position (better than dichotomy)
1639 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1640 + pos_min - approximate_keyframe_distance;
1641 }else if(no_change==1){
1642 // bisection, if interpolation failed to change min or max pos last time
1643 pos = (pos_min + pos_limit)>>1;
1645 /* linear search if bisection failed, can only happen if there
1646 are very few or no keyframes between min/max */
1651 else if(pos > pos_limit)
1655 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1660 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1661 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1662 pos_limit, start_pos, no_change);
1663 if(ts == AV_NOPTS_VALUE){
1664 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1667 assert(ts != AV_NOPTS_VALUE);
1668 if (target_ts <= ts) {
1669 pos_limit = start_pos - 1;
1673 if (target_ts >= ts) {
1679 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1680 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1682 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1684 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1685 av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1686 pos, ts_min, target_ts, ts_max);
1691 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1692 int64_t pos_min, pos_max;
1696 if (stream_index < 0)
1699 st= s->streams[stream_index];
1702 pos_min = s->data_offset;
1703 pos_max = avio_size(s->pb) - 1;
1705 if (pos < pos_min) pos= pos_min;
1706 else if(pos > pos_max) pos= pos_max;
1708 avio_seek(s->pb, pos, SEEK_SET);
1711 av_update_cur_dts(s, st, ts);
1716 static int seek_frame_generic(AVFormatContext *s,
1717 int stream_index, int64_t timestamp, int flags)
1724 st = s->streams[stream_index];
1726 index = av_index_search_timestamp(st, timestamp, flags);
1728 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1731 if(index < 0 || index==st->nb_index_entries-1){
1735 if(st->nb_index_entries){
1736 assert(st->index_entries);
1737 ie= &st->index_entries[st->nb_index_entries-1];
1738 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1740 av_update_cur_dts(s, st, ie->timestamp);
1742 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1748 ret = av_read_frame(s, &pkt);
1749 }while(ret == AVERROR(EAGAIN));
1752 av_free_packet(&pkt);
1753 if(stream_index == pkt.stream_index){
1754 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1758 index = av_index_search_timestamp(st, timestamp, flags);
1763 ff_read_frame_flush(s);
1764 if (s->iformat->read_seek){
1765 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1768 ie = &st->index_entries[index];
1769 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1771 av_update_cur_dts(s, st, ie->timestamp);
1776 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1781 ff_read_frame_flush(s);
1783 if(flags & AVSEEK_FLAG_BYTE)
1784 return seek_frame_byte(s, stream_index, timestamp, flags);
1786 if(stream_index < 0){
1787 stream_index= av_find_default_stream_index(s);
1788 if(stream_index < 0)
1791 st= s->streams[stream_index];
1792 /* timestamp for default must be expressed in AV_TIME_BASE units */
1793 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1796 /* first, we try the format specific seek */
1797 if (s->iformat->read_seek)
1798 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1805 if(s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH))
1806 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1807 else if (!(s->iformat->flags & AVFMT_NOGENSEARCH))
1808 return seek_frame_generic(s, stream_index, timestamp, flags);
1813 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1815 if(min_ts > ts || max_ts < ts)
1818 ff_read_frame_flush(s);
1820 if (s->iformat->read_seek2)
1821 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1823 if(s->iformat->read_timestamp){
1824 //try to seek via read_timestamp()
1827 //Fallback to old API if new is not implemented but old is
1828 //Note the old has somewat different sematics
1829 if(s->iformat->read_seek || 1)
1830 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1832 // try some generic seek like seek_frame_generic() but with new ts semantics
1835 /*******************************************************/
1838 * Return TRUE if the stream has accurate duration in any stream.
1840 * @return TRUE if the stream has accurate duration for at least one component.
1842 static int has_duration(AVFormatContext *ic)
1847 for(i = 0;i < ic->nb_streams; i++) {
1848 st = ic->streams[i];
1849 if (st->duration != AV_NOPTS_VALUE)
1856 * Estimate the stream timings from the one of each components.
1858 * Also computes the global bitrate if possible.
1860 static void update_stream_timings(AVFormatContext *ic)
1862 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
1863 int64_t duration, duration1;
1867 start_time = INT64_MAX;
1868 start_time_text = INT64_MAX;
1869 end_time = INT64_MIN;
1870 duration = INT64_MIN;
1871 for(i = 0;i < ic->nb_streams; i++) {
1872 st = ic->streams[i];
1873 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1874 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1875 if (st->codec->codec_id == CODEC_ID_DVB_TELETEXT) {
1876 if (start_time1 < start_time_text)
1877 start_time_text = start_time1;
1879 if (start_time1 < start_time)
1880 start_time = start_time1;
1881 if (st->duration != AV_NOPTS_VALUE) {
1882 end_time1 = start_time1
1883 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1884 if (end_time1 > end_time)
1885 end_time = end_time1;
1888 if (st->duration != AV_NOPTS_VALUE) {
1889 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1890 if (duration1 > duration)
1891 duration = duration1;
1894 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
1895 start_time = start_time_text;
1896 if (start_time != INT64_MAX) {
1897 ic->start_time = start_time;
1898 if (end_time != INT64_MIN) {
1899 if (end_time - start_time > duration)
1900 duration = end_time - start_time;
1903 if (duration != INT64_MIN) {
1904 ic->duration = duration;
1905 if (ic->file_size > 0) {
1906 /* compute the bitrate */
1907 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1908 (double)ic->duration;
1913 static void fill_all_stream_timings(AVFormatContext *ic)
1918 update_stream_timings(ic);
1919 for(i = 0;i < ic->nb_streams; i++) {
1920 st = ic->streams[i];
1921 if (st->start_time == AV_NOPTS_VALUE) {
1922 if(ic->start_time != AV_NOPTS_VALUE)
1923 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1924 if(ic->duration != AV_NOPTS_VALUE)
1925 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1930 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
1932 int64_t filesize, duration;
1936 /* if bit_rate is already set, we believe it */
1937 if (ic->bit_rate <= 0) {
1939 for(i=0;i<ic->nb_streams;i++) {
1940 st = ic->streams[i];
1941 if (st->codec->bit_rate > 0)
1942 bit_rate += st->codec->bit_rate;
1944 ic->bit_rate = bit_rate;
1947 /* if duration is already set, we believe it */
1948 if (ic->duration == AV_NOPTS_VALUE &&
1949 ic->bit_rate != 0 &&
1950 ic->file_size != 0) {
1951 filesize = ic->file_size;
1953 for(i = 0; i < ic->nb_streams; i++) {
1954 st = ic->streams[i];
1955 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1956 if (st->duration == AV_NOPTS_VALUE)
1957 st->duration = duration;
1963 #define DURATION_MAX_READ_SIZE 250000
1964 #define DURATION_MAX_RETRY 3
1966 /* only usable for MPEG-PS streams */
1967 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1969 AVPacket pkt1, *pkt = &pkt1;
1971 int read_size, i, ret;
1973 int64_t filesize, offset, duration;
1978 /* flush packet queue */
1979 flush_packet_queue(ic);
1981 for (i=0; i<ic->nb_streams; i++) {
1982 st = ic->streams[i];
1983 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1984 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
1987 av_parser_close(st->parser);
1989 av_free_packet(&st->cur_pkt);
1993 /* estimate the end time (duration) */
1994 /* XXX: may need to support wrapping */
1995 filesize = ic->file_size;
1996 end_time = AV_NOPTS_VALUE;
1998 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2002 avio_seek(ic->pb, offset, SEEK_SET);
2005 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2009 ret = av_read_packet(ic, pkt);
2010 }while(ret == AVERROR(EAGAIN));
2013 read_size += pkt->size;
2014 st = ic->streams[pkt->stream_index];
2015 if (pkt->pts != AV_NOPTS_VALUE &&
2016 (st->start_time != AV_NOPTS_VALUE ||
2017 st->first_dts != AV_NOPTS_VALUE)) {
2018 duration = end_time = pkt->pts;
2019 if (st->start_time != AV_NOPTS_VALUE) duration -= st->start_time;
2020 else duration -= st->first_dts;
2022 duration += 1LL<<st->pts_wrap_bits;
2024 if (st->duration == AV_NOPTS_VALUE ||
2025 st->duration < duration)
2026 st->duration = duration;
2029 av_free_packet(pkt);
2031 }while( end_time==AV_NOPTS_VALUE
2032 && filesize > (DURATION_MAX_READ_SIZE<<retry)
2033 && ++retry <= DURATION_MAX_RETRY);
2035 fill_all_stream_timings(ic);
2037 avio_seek(ic->pb, old_offset, SEEK_SET);
2038 for (i=0; i<ic->nb_streams; i++) {
2040 st->cur_dts= st->first_dts;
2041 st->last_IP_pts = AV_NOPTS_VALUE;
2042 st->reference_dts = AV_NOPTS_VALUE;
2046 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2050 /* get the file size, if possible */
2051 if (ic->iformat->flags & AVFMT_NOFILE) {
2054 file_size = avio_size(ic->pb);
2058 ic->file_size = file_size;
2060 if ((!strcmp(ic->iformat->name, "mpeg") ||
2061 !strcmp(ic->iformat->name, "mpegts")) &&
2062 file_size && ic->pb->seekable) {
2063 /* get accurate estimate from the PTSes */
2064 estimate_timings_from_pts(ic, old_offset);
2065 } else if (has_duration(ic)) {
2066 /* at least one component has timings - we use them for all
2068 fill_all_stream_timings(ic);
2070 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2071 /* less precise: use bitrate info */
2072 estimate_timings_from_bit_rate(ic);
2074 update_stream_timings(ic);
2079 AVStream av_unused *st;
2080 for(i = 0;i < ic->nb_streams; i++) {
2081 st = ic->streams[i];
2082 printf("%d: start_time: %0.3f duration: %0.3f\n",
2083 i, (double)st->start_time / AV_TIME_BASE,
2084 (double)st->duration / AV_TIME_BASE);
2086 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2087 (double)ic->start_time / AV_TIME_BASE,
2088 (double)ic->duration / AV_TIME_BASE,
2089 ic->bit_rate / 1000);
2094 static int has_codec_parameters(AVCodecContext *avctx)
2097 switch (avctx->codec_type) {
2098 case AVMEDIA_TYPE_AUDIO:
2099 val = avctx->sample_rate && avctx->channels && avctx->sample_fmt != AV_SAMPLE_FMT_NONE;
2100 if(!avctx->frame_size &&
2101 (avctx->codec_id == CODEC_ID_VORBIS ||
2102 avctx->codec_id == CODEC_ID_AAC ||
2103 avctx->codec_id == CODEC_ID_MP1 ||
2104 avctx->codec_id == CODEC_ID_MP2 ||
2105 avctx->codec_id == CODEC_ID_MP3 ||
2106 avctx->codec_id == CODEC_ID_SPEEX ||
2107 avctx->codec_id == CODEC_ID_CELT))
2110 case AVMEDIA_TYPE_VIDEO:
2111 val = avctx->width && avctx->pix_fmt != PIX_FMT_NONE;
2117 return avctx->codec_id != CODEC_ID_NONE && val != 0;
2120 static int has_decode_delay_been_guessed(AVStream *st)
2122 return st->codec->codec_id != CODEC_ID_H264 ||
2123 st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2126 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2130 int got_picture, data_size, ret=0;
2133 if(!st->codec->codec){
2134 codec = avcodec_find_decoder(st->codec->codec_id);
2137 ret = avcodec_open2(st->codec, codec, options);
2142 if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st) ||
2143 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF)) {
2144 switch(st->codec->codec_type) {
2145 case AVMEDIA_TYPE_VIDEO:
2146 avcodec_get_frame_defaults(&picture);
2147 ret = avcodec_decode_video2(st->codec, &picture,
2148 &got_picture, avpkt);
2150 case AVMEDIA_TYPE_AUDIO:
2151 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2152 samples = av_malloc(data_size);
2155 ret = avcodec_decode_audio3(st->codec, samples,
2167 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2169 while (tags->id != CODEC_ID_NONE) {
2177 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2180 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2181 if(tag == tags[i].tag)
2184 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2185 if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2188 return CODEC_ID_NONE;
2191 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2194 for(i=0; tags && tags[i]; i++){
2195 int tag= ff_codec_get_tag(tags[i], id);
2201 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2204 for(i=0; tags && tags[i]; i++){
2205 enum CodecID id= ff_codec_get_id(tags[i], tag);
2206 if(id!=CODEC_ID_NONE) return id;
2208 return CODEC_ID_NONE;
2211 static void compute_chapters_end(AVFormatContext *s)
2214 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2216 for (i = 0; i < s->nb_chapters; i++)
2217 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2218 AVChapter *ch = s->chapters[i];
2219 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2222 for (j = 0; j < s->nb_chapters; j++) {
2223 AVChapter *ch1 = s->chapters[j];
2224 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2225 if (j != i && next_start > ch->start && next_start < end)
2228 ch->end = (end == INT64_MAX) ? ch->start : end;
2232 static int get_std_framerate(int i){
2233 if(i<60*12) return i*1001;
2234 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2238 * Is the time base unreliable.
2239 * This is a heuristic to balance between quick acceptance of the values in
2240 * the headers vs. some extra checks.
2241 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2242 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2243 * And there are "variable" fps files this needs to detect as well.
2245 static int tb_unreliable(AVCodecContext *c){
2246 if( c->time_base.den >= 101L*c->time_base.num
2247 || c->time_base.den < 5L*c->time_base.num
2248 /* || c->codec_tag == AV_RL32("DIVX")
2249 || c->codec_tag == AV_RL32("XVID")*/
2250 || c->codec_id == CODEC_ID_MPEG2VIDEO
2251 || c->codec_id == CODEC_ID_H264
2257 #if FF_API_FORMAT_PARAMETERS
2258 int av_find_stream_info(AVFormatContext *ic)
2260 return avformat_find_stream_info(ic, NULL);
2264 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2266 int i, count, ret, read_size, j;
2268 AVPacket pkt1, *pkt;
2269 int64_t old_offset = avio_tell(ic->pb);
2270 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2272 for(i=0;i<ic->nb_streams;i++) {
2274 st = ic->streams[i];
2275 if (st->codec->codec_id == CODEC_ID_AAC && st->codec->extradata_size) {
2276 // We need to discard these since they can be plain wrong for
2277 // backwards compatible HE-AAC signaling.
2278 // But when we have no extradata we need to keep them or we can't
2279 // play anything at all.
2280 st->codec->sample_rate = 0;
2281 st->codec->frame_size = 0;
2282 st->codec->channels = 0;
2285 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2286 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2287 /* if(!st->time_base.num)
2289 if(!st->codec->time_base.num)
2290 st->codec->time_base= st->time_base;
2292 //only for the split stuff
2293 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2294 st->parser = av_parser_init(st->codec->codec_id);
2295 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2296 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2299 assert(!st->codec->codec);
2300 codec = avcodec_find_decoder(st->codec->codec_id);
2302 /* Ensure that subtitle_header is properly set. */
2303 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2304 && codec && !st->codec->codec)
2305 avcodec_open2(st->codec, codec, options ? &options[i] : NULL);
2307 //try to just open decoders, in case this is enough to get parameters
2308 if(!has_codec_parameters(st->codec)){
2309 if (codec && !st->codec->codec)
2310 avcodec_open2(st->codec, codec, options ? &options[i] : NULL);
2314 for (i=0; i<ic->nb_streams; i++) {
2315 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2321 if(url_interrupt_cb()){
2323 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2327 /* check if one codec still needs to be handled */
2328 for(i=0;i<ic->nb_streams;i++) {
2329 int fps_analyze_framecount = 20;
2331 st = ic->streams[i];
2332 if (!has_codec_parameters(st->codec))
2334 /* if the timebase is coarse (like the usual millisecond precision
2335 of mkv), we need to analyze more frames to reliably arrive at
2337 if (av_q2d(st->time_base) > 0.0005)
2338 fps_analyze_framecount *= 2;
2339 if (ic->fps_probe_size >= 0)
2340 fps_analyze_framecount = ic->fps_probe_size;
2341 /* variable fps and no guess at the real fps */
2342 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2343 && st->info->duration_count < fps_analyze_framecount
2344 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2346 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2348 if(st->first_dts == AV_NOPTS_VALUE)
2351 if (i == ic->nb_streams) {
2352 /* NOTE: if the format has no header, then we need to read
2353 some packets to get most of the streams, so we cannot
2355 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2356 /* if we found the info for all the codecs, we can stop */
2358 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2362 /* we did not get all the codec info, but we read too much data */
2363 if (read_size >= ic->probesize) {
2365 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2369 /* NOTE: a new stream can be added there if no header in file
2370 (AVFMTCTX_NOHEADER) */
2371 ret = read_frame_internal(ic, &pkt1);
2372 if (ret == AVERROR(EAGAIN))
2377 ret = -1; /* we could not have all the codec parameters before EOF */
2378 for(i=0;i<ic->nb_streams;i++) {
2379 st = ic->streams[i];
2380 if (!has_codec_parameters(st->codec)){
2382 avcodec_string(buf, sizeof(buf), st->codec, 0);
2383 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2391 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2392 if ((ret = av_dup_packet(pkt)) < 0)
2393 goto find_stream_info_err;
2395 read_size += pkt->size;
2397 st = ic->streams[pkt->stream_index];
2398 if (st->codec_info_nb_frames>1) {
2400 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) {
2401 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64"\n", ic->max_analyze_duration, t);
2404 st->info->codec_info_duration += pkt->duration;
2407 int64_t last = st->info->last_dts;
2408 int64_t duration= pkt->dts - last;
2410 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2411 double dur= duration * av_q2d(st->time_base);
2413 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2414 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2415 if (st->info->duration_count < 2)
2416 memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2417 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2418 int framerate= get_std_framerate(i);
2419 int ticks= lrintf(dur*framerate/(1001*12));
2420 double error= dur - ticks*1001*12/(double)framerate;
2421 st->info->duration_error[i] += error*error;
2423 st->info->duration_count++;
2424 // ignore the first 4 values, they might have some random jitter
2425 if (st->info->duration_count > 3)
2426 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2428 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2429 st->info->last_dts = pkt->dts;
2431 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2432 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2434 st->codec->extradata_size= i;
2435 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2436 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2437 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2441 /* if still no information, we try to open the codec and to
2442 decompress the frame. We try to avoid that in most cases as
2443 it takes longer and uses more memory. For MPEG-4, we need to
2444 decompress for QuickTime.
2446 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2447 least one frame of codec data, this makes sure the codec initializes
2448 the channel configuration and does not only trust the values from the container.
2450 try_decode_frame(st, pkt, (options && i < orig_nb_streams )? &options[i] : NULL);
2452 st->codec_info_nb_frames++;
2456 // close codecs which were opened in try_decode_frame()
2457 for(i=0;i<ic->nb_streams;i++) {
2458 st = ic->streams[i];
2459 if(st->codec->codec)
2460 avcodec_close(st->codec);
2462 for(i=0;i<ic->nb_streams;i++) {
2463 st = ic->streams[i];
2464 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2465 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2466 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2467 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2468 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2469 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2470 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2471 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2472 st->codec->codec_tag= tag;
2475 // the check for tb_unreliable() is not completely correct, since this is not about handling
2476 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2477 // ipmovie.c produces.
2478 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)
2479 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);
2480 if (st->info->duration_count && !st->r_frame_rate.num
2481 && tb_unreliable(st->codec) /*&&
2482 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2483 st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2485 double best_error= 2*av_q2d(st->time_base);
2486 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2488 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2489 double error = st->info->duration_error[j] * get_std_framerate(j);
2490 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2491 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2492 if(error < best_error){
2494 num = get_std_framerate(j);
2497 // do not increase frame rate by more than 1 % in order to match a standard rate.
2498 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2499 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2502 if (!st->r_frame_rate.num){
2503 if( st->codec->time_base.den * (int64_t)st->time_base.num
2504 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2505 st->r_frame_rate.num = st->codec->time_base.den;
2506 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2508 st->r_frame_rate.num = st->time_base.den;
2509 st->r_frame_rate.den = st->time_base.num;
2512 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2513 if(!st->codec->bits_per_coded_sample)
2514 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2515 // set stream disposition based on audio service type
2516 switch (st->codec->audio_service_type) {
2517 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2518 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2519 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2520 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2521 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2522 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2523 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2524 st->disposition = AV_DISPOSITION_COMMENT; break;
2525 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2526 st->disposition = AV_DISPOSITION_KARAOKE; break;
2531 estimate_timings(ic, old_offset);
2533 compute_chapters_end(ic);
2536 /* correct DTS for B-frame streams with no timestamps */
2537 for(i=0;i<ic->nb_streams;i++) {
2538 st = ic->streams[i];
2539 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2541 ppktl = &ic->packet_buffer;
2543 if(ppkt1->stream_index != i)
2545 if(ppkt1->pkt->dts < 0)
2547 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2549 ppkt1->pkt->dts -= delta;
2554 st->cur_dts -= delta;
2560 find_stream_info_err:
2561 for (i=0; i < ic->nb_streams; i++)
2562 av_freep(&ic->streams[i]->info);
2566 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2570 for (i = 0; i < ic->nb_programs; i++)
2571 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2572 if (ic->programs[i]->stream_index[j] == s)
2573 return ic->programs[i];
2577 int av_find_best_stream(AVFormatContext *ic,
2578 enum AVMediaType type,
2579 int wanted_stream_nb,
2581 AVCodec **decoder_ret,
2584 int i, nb_streams = ic->nb_streams;
2585 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2586 unsigned *program = NULL;
2587 AVCodec *decoder = NULL, *best_decoder = NULL;
2589 if (related_stream >= 0 && wanted_stream_nb < 0) {
2590 AVProgram *p = find_program_from_stream(ic, related_stream);
2592 program = p->stream_index;
2593 nb_streams = p->nb_stream_indexes;
2596 for (i = 0; i < nb_streams; i++) {
2597 int real_stream_index = program ? program[i] : i;
2598 AVStream *st = ic->streams[real_stream_index];
2599 AVCodecContext *avctx = st->codec;
2600 if (avctx->codec_type != type)
2602 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2604 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2607 decoder = avcodec_find_decoder(st->codec->codec_id);
2610 ret = AVERROR_DECODER_NOT_FOUND;
2614 if (best_count >= st->codec_info_nb_frames)
2616 best_count = st->codec_info_nb_frames;
2617 ret = real_stream_index;
2618 best_decoder = decoder;
2619 if (program && i == nb_streams - 1 && ret < 0) {
2621 nb_streams = ic->nb_streams;
2622 i = 0; /* no related stream found, try again with everything */
2626 *decoder_ret = best_decoder;
2630 /*******************************************************/
2632 int av_read_play(AVFormatContext *s)
2634 if (s->iformat->read_play)
2635 return s->iformat->read_play(s);
2637 return avio_pause(s->pb, 0);
2638 return AVERROR(ENOSYS);
2641 int av_read_pause(AVFormatContext *s)
2643 if (s->iformat->read_pause)
2644 return s->iformat->read_pause(s);
2646 return avio_pause(s->pb, 1);
2647 return AVERROR(ENOSYS);
2650 void av_close_input_stream(AVFormatContext *s)
2652 flush_packet_queue(s);
2653 if (s->iformat->read_close)
2654 s->iformat->read_close(s);
2655 avformat_free_context(s);
2658 void avformat_free_context(AVFormatContext *s)
2664 if (s->iformat && s->iformat->priv_class && s->priv_data)
2665 av_opt_free(s->priv_data);
2667 for(i=0;i<s->nb_streams;i++) {
2668 /* free all data in a stream component */
2671 av_parser_close(st->parser);
2672 av_free_packet(&st->cur_pkt);
2674 av_dict_free(&st->metadata);
2675 av_free(st->index_entries);
2676 av_free(st->codec->extradata);
2677 av_free(st->codec->subtitle_header);
2679 av_free(st->priv_data);
2683 for(i=s->nb_programs-1; i>=0; i--) {
2684 av_dict_free(&s->programs[i]->metadata);
2685 av_freep(&s->programs[i]->stream_index);
2686 av_freep(&s->programs[i]);
2688 av_freep(&s->programs);
2689 av_freep(&s->priv_data);
2690 while(s->nb_chapters--) {
2691 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2692 av_free(s->chapters[s->nb_chapters]);
2694 av_freep(&s->chapters);
2695 av_dict_free(&s->metadata);
2696 av_freep(&s->streams);
2700 void av_close_input_file(AVFormatContext *s)
2702 AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2704 av_close_input_stream(s);
2709 AVStream *av_new_stream(AVFormatContext *s, int id)
2715 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2717 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2720 s->streams = streams;
2722 st = av_mallocz(sizeof(AVStream));
2725 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2730 st->codec = avcodec_alloc_context3(NULL);
2732 /* no default bitrate if decoding */
2733 st->codec->bit_rate = 0;
2735 st->index = s->nb_streams;
2737 st->start_time = AV_NOPTS_VALUE;
2738 st->duration = AV_NOPTS_VALUE;
2739 /* we set the current DTS to 0 so that formats without any timestamps
2740 but durations get some timestamps, formats with some unknown
2741 timestamps have their first few packets buffered and the
2742 timestamps corrected before they are returned to the user */
2744 st->first_dts = AV_NOPTS_VALUE;
2745 st->probe_packets = MAX_PROBE_PACKETS;
2747 /* default pts setting is MPEG-like */
2748 av_set_pts_info(st, 33, 1, 90000);
2749 st->last_IP_pts = AV_NOPTS_VALUE;
2750 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2751 st->pts_buffer[i]= AV_NOPTS_VALUE;
2752 st->reference_dts = AV_NOPTS_VALUE;
2754 st->sample_aspect_ratio = (AVRational){0,1};
2756 s->streams[s->nb_streams++] = st;
2760 AVProgram *av_new_program(AVFormatContext *ac, int id)
2762 AVProgram *program=NULL;
2765 av_dlog(ac, "new_program: id=0x%04x\n", id);
2767 for(i=0; i<ac->nb_programs; i++)
2768 if(ac->programs[i]->id == id)
2769 program = ac->programs[i];
2772 program = av_mallocz(sizeof(AVProgram));
2775 dynarray_add(&ac->programs, &ac->nb_programs, program);
2776 program->discard = AVDISCARD_NONE;
2783 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2785 AVChapter *chapter = NULL;
2788 for(i=0; i<s->nb_chapters; i++)
2789 if(s->chapters[i]->id == id)
2790 chapter = s->chapters[i];
2793 chapter= av_mallocz(sizeof(AVChapter));
2796 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2798 av_dict_set(&chapter->metadata, "title", title, 0);
2800 chapter->time_base= time_base;
2801 chapter->start = start;
2807 /************************************************************/
2808 /* output media file */
2810 #if FF_API_FORMAT_PARAMETERS
2811 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2813 if (s->oformat->priv_data_size > 0) {
2814 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2816 return AVERROR(ENOMEM);
2817 if (s->oformat->priv_class) {
2818 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2819 av_opt_set_defaults(s->priv_data);
2822 s->priv_data = NULL;
2828 int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
2829 const char *format, const char *filename)
2831 AVFormatContext *s = avformat_alloc_context();
2840 oformat = av_guess_format(format, NULL, NULL);
2842 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
2843 ret = AVERROR(EINVAL);
2847 oformat = av_guess_format(NULL, filename, NULL);
2849 ret = AVERROR(EINVAL);
2850 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
2857 s->oformat = oformat;
2858 if (s->oformat->priv_data_size > 0) {
2859 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2862 if (s->oformat->priv_class) {
2863 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2864 av_opt_set_defaults(s->priv_data);
2867 s->priv_data = NULL;
2870 av_strlcpy(s->filename, filename, sizeof(s->filename));
2874 av_log(s, AV_LOG_ERROR, "Out of memory\n");
2875 ret = AVERROR(ENOMEM);
2877 avformat_free_context(s);
2881 #if FF_API_ALLOC_OUTPUT_CONTEXT
2882 AVFormatContext *avformat_alloc_output_context(const char *format,
2883 AVOutputFormat *oformat, const char *filename)
2885 AVFormatContext *avctx;
2886 int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
2887 return ret < 0 ? NULL : avctx;
2891 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2893 const AVCodecTag *avctag;
2895 enum CodecID id = CODEC_ID_NONE;
2896 unsigned int tag = 0;
2899 * Check that tag + id is in the table
2900 * If neither is in the table -> OK
2901 * If tag is in the table with another id -> FAIL
2902 * If id is in the table with another tag -> FAIL unless strict < normal
2904 for (n = 0; s->oformat->codec_tag[n]; n++) {
2905 avctag = s->oformat->codec_tag[n];
2906 while (avctag->id != CODEC_ID_NONE) {
2907 if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2909 if (id == st->codec->codec_id)
2912 if (avctag->id == st->codec->codec_id)
2917 if (id != CODEC_ID_NONE)
2919 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2924 #if FF_API_FORMAT_PARAMETERS
2925 int av_write_header(AVFormatContext *s)
2927 return avformat_write_header(s, NULL);
2931 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
2935 AVDictionary *tmp = NULL;
2938 av_dict_copy(&tmp, *options, 0);
2939 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
2941 if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
2942 (ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
2945 // some sanity checks
2946 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2947 av_log(s, AV_LOG_ERROR, "no streams\n");
2948 ret = AVERROR(EINVAL);
2952 for(i=0;i<s->nb_streams;i++) {
2955 switch (st->codec->codec_type) {
2956 case AVMEDIA_TYPE_AUDIO:
2957 if(st->codec->sample_rate<=0){
2958 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2959 ret = AVERROR(EINVAL);
2962 if(!st->codec->block_align)
2963 st->codec->block_align = st->codec->channels *
2964 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2966 case AVMEDIA_TYPE_VIDEO:
2967 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2968 av_log(s, AV_LOG_ERROR, "time base not set\n");
2969 ret = AVERROR(EINVAL);
2972 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2973 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2974 ret = AVERROR(EINVAL);
2977 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2978 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2979 ret = AVERROR(EINVAL);
2985 if(s->oformat->codec_tag){
2986 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)){
2987 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2988 st->codec->codec_tag= 0;
2990 if(st->codec->codec_tag){
2991 if (!validate_codec_tag(s, st)) {
2993 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2994 av_log(s, AV_LOG_ERROR,
2995 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2996 tagbuf, st->codec->codec_tag, st->codec->codec_id);
2997 ret = AVERROR_INVALIDDATA;
3001 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
3004 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
3005 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
3006 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
3009 if (!s->priv_data && s->oformat->priv_data_size > 0) {
3010 s->priv_data = av_mallocz(s->oformat->priv_data_size);
3011 if (!s->priv_data) {
3012 ret = AVERROR(ENOMEM);
3015 if (s->oformat->priv_class) {
3016 *(const AVClass**)s->priv_data= s->oformat->priv_class;
3017 av_opt_set_defaults(s->priv_data);
3018 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3023 /* set muxer identification string */
3024 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
3025 av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
3028 if(s->oformat->write_header){
3029 ret = s->oformat->write_header(s);
3034 /* init PTS generation */
3035 for(i=0;i<s->nb_streams;i++) {
3036 int64_t den = AV_NOPTS_VALUE;
3039 switch (st->codec->codec_type) {
3040 case AVMEDIA_TYPE_AUDIO:
3041 den = (int64_t)st->time_base.num * st->codec->sample_rate;
3043 case AVMEDIA_TYPE_VIDEO:
3044 den = (int64_t)st->time_base.num * st->codec->time_base.den;
3049 if (den != AV_NOPTS_VALUE) {
3051 ret = AVERROR_INVALIDDATA;
3054 frac_init(&st->pts, 0, 0, den);
3059 av_dict_free(options);
3068 //FIXME merge with compute_pkt_fields
3069 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3070 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3071 int num, den, frame_size, i;
3073 av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3074 pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3076 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
3077 return AVERROR(EINVAL);*/
3079 /* duration field */
3080 if (pkt->duration == 0) {
3081 compute_frame_duration(&num, &den, st, NULL, pkt);
3083 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3087 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3090 //XXX/FIXME this is a temporary hack until all encoders output pts
3091 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3093 // pkt->pts= st->cur_dts;
3094 pkt->pts= st->pts.val;
3097 //calculate dts from pts
3098 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3099 st->pts_buffer[0]= pkt->pts;
3100 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3101 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3102 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3103 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3105 pkt->dts= st->pts_buffer[0];
3108 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)){
3109 av_log(s, AV_LOG_ERROR,
3110 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3111 st->index, st->cur_dts, pkt->dts);
3112 return AVERROR(EINVAL);
3114 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3115 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3116 return AVERROR(EINVAL);
3119 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3120 st->cur_dts= pkt->dts;
3121 st->pts.val= pkt->dts;
3124 switch (st->codec->codec_type) {
3125 case AVMEDIA_TYPE_AUDIO:
3126 frame_size = get_audio_frame_size(st->codec, pkt->size);
3128 /* HACK/FIXME, we skip the initial 0 size packets as they are most
3129 likely equal to the encoder delay, but it would be better if we
3130 had the real timestamps from the encoder */
3131 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3132 frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3135 case AVMEDIA_TYPE_VIDEO:
3136 frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3144 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3146 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3148 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3151 ret= s->oformat->write_packet(s, pkt);
3154 s->streams[pkt->stream_index]->nb_frames++;
3158 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3159 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3161 AVPacketList **next_point, *this_pktl;
3163 this_pktl = av_mallocz(sizeof(AVPacketList));
3164 this_pktl->pkt= *pkt;
3165 pkt->destruct= NULL; // do not free original but only the copy
3166 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
3168 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3169 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3171 next_point = &s->packet_buffer;
3174 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3175 while(!compare(s, &(*next_point)->pkt, pkt)){
3176 next_point= &(*next_point)->next;
3180 next_point = &(s->packet_buffer_end->next);
3183 assert(!*next_point);
3185 s->packet_buffer_end= this_pktl;
3188 this_pktl->next= *next_point;
3190 s->streams[pkt->stream_index]->last_in_packet_buffer=
3191 *next_point= this_pktl;
3194 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3196 AVStream *st = s->streams[ pkt ->stream_index];
3197 AVStream *st2= s->streams[ next->stream_index];
3198 int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3202 return pkt->stream_index < next->stream_index;
3206 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3212 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3215 for(i=0; i < s->nb_streams; i++)
3216 stream_count+= !!s->streams[i]->last_in_packet_buffer;
3218 if(stream_count && (s->nb_streams == stream_count || flush)){
3219 pktl= s->packet_buffer;
3222 s->packet_buffer= pktl->next;
3223 if(!s->packet_buffer)
3224 s->packet_buffer_end= NULL;
3226 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3227 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3231 av_init_packet(out);
3237 * Interleave an AVPacket correctly so it can be muxed.
3238 * @param out the interleaved packet will be output here
3239 * @param in the input packet
3240 * @param flush 1 if no further packets are available as input and all
3241 * remaining packets should be output
3242 * @return 1 if a packet was output, 0 if no packet could be output,
3243 * < 0 if an error occurred
3245 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3246 if(s->oformat->interleave_packet)
3247 return s->oformat->interleave_packet(s, out, in, flush);
3249 return av_interleave_packet_per_dts(s, out, in, flush);
3252 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3253 AVStream *st= s->streams[ pkt->stream_index];
3256 //FIXME/XXX/HACK drop zero sized packets
3257 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3260 av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3261 pkt->size, pkt->dts, pkt->pts);
3262 if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3265 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3266 return AVERROR(EINVAL);
3270 int ret= interleave_packet(s, &opkt, pkt, 0);
3271 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3274 ret= s->oformat->write_packet(s, &opkt);
3276 s->streams[opkt.stream_index]->nb_frames++;
3278 av_free_packet(&opkt);
3283 if(url_ferror(s->pb))
3284 return url_ferror(s->pb);
3288 int av_write_trailer(AVFormatContext *s)
3294 ret= interleave_packet(s, &pkt, NULL, 1);
3295 if(ret<0) //FIXME cleanup needed for ret<0 ?
3300 ret= s->oformat->write_packet(s, &pkt);
3302 s->streams[pkt.stream_index]->nb_frames++;
3304 av_free_packet(&pkt);
3308 if(url_ferror(s->pb))
3312 if(s->oformat->write_trailer)
3313 ret = s->oformat->write_trailer(s);
3316 ret=url_ferror(s->pb);
3317 for(i=0;i<s->nb_streams;i++) {
3318 av_freep(&s->streams[i]->priv_data);
3319 av_freep(&s->streams[i]->index_entries);
3321 if (s->iformat && s->iformat->priv_class)
3322 av_opt_free(s->priv_data);
3323 av_freep(&s->priv_data);
3327 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
3328 int64_t *dts, int64_t *wall)
3330 if (!s->oformat || !s->oformat->get_output_timestamp)
3331 return AVERROR(ENOSYS);
3332 s->oformat->get_output_timestamp(s, stream, dts, wall);
3336 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3339 AVProgram *program=NULL;
3342 if (idx >= ac->nb_streams) {
3343 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3347 for(i=0; i<ac->nb_programs; i++){
3348 if(ac->programs[i]->id != progid)
3350 program = ac->programs[i];
3351 for(j=0; j<program->nb_stream_indexes; j++)
3352 if(program->stream_index[j] == idx)
3355 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3358 program->stream_index = tmp;
3359 program->stream_index[program->nb_stream_indexes++] = idx;
3364 static void print_fps(double d, const char *postfix){
3365 uint64_t v= lrintf(d*100);
3366 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3367 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3368 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3371 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3373 if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3374 AVDictionaryEntry *tag=NULL;
3376 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3377 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3378 if(strcmp("language", tag->key)){
3381 av_strlcpy(tmp, tag->value, sizeof(tmp));
3382 for(i=0; i<strlen(tmp); i++) if(tmp[i]==0xd) tmp[i]=' ';
3383 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tmp);
3389 /* "user interface" functions */
3390 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3393 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3394 AVStream *st = ic->streams[i];
3395 int g = av_gcd(st->time_base.num, st->time_base.den);
3396 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3397 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3398 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
3399 /* the pid is an important information, so we display it */
3400 /* XXX: add a generic system */
3401 if (flags & AVFMT_SHOW_IDS)
3402 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3404 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3405 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3406 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3407 if (st->sample_aspect_ratio.num && // default
3408 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3409 AVRational display_aspect_ratio;
3410 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3411 st->codec->width*st->sample_aspect_ratio.num,
3412 st->codec->height*st->sample_aspect_ratio.den,
3414 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3415 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3416 display_aspect_ratio.num, display_aspect_ratio.den);
3418 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3419 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3420 print_fps(av_q2d(st->avg_frame_rate), "fps");
3421 if(st->r_frame_rate.den && st->r_frame_rate.num)
3422 print_fps(av_q2d(st->r_frame_rate), "tbr");
3423 if(st->time_base.den && st->time_base.num)
3424 print_fps(1/av_q2d(st->time_base), "tbn");
3425 if(st->codec->time_base.den && st->codec->time_base.num)
3426 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3428 if (st->disposition & AV_DISPOSITION_DEFAULT)
3429 av_log(NULL, AV_LOG_INFO, " (default)");
3430 if (st->disposition & AV_DISPOSITION_DUB)
3431 av_log(NULL, AV_LOG_INFO, " (dub)");
3432 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3433 av_log(NULL, AV_LOG_INFO, " (original)");
3434 if (st->disposition & AV_DISPOSITION_COMMENT)
3435 av_log(NULL, AV_LOG_INFO, " (comment)");
3436 if (st->disposition & AV_DISPOSITION_LYRICS)
3437 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3438 if (st->disposition & AV_DISPOSITION_KARAOKE)
3439 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3440 if (st->disposition & AV_DISPOSITION_FORCED)
3441 av_log(NULL, AV_LOG_INFO, " (forced)");
3442 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3443 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3444 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3445 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3446 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3447 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3448 av_log(NULL, AV_LOG_INFO, "\n");
3449 dump_metadata(NULL, st->metadata, " ");
3452 #if FF_API_DUMP_FORMAT
3453 void dump_format(AVFormatContext *ic,
3458 av_dump_format(ic, index, url, is_output);
3462 void av_dump_format(AVFormatContext *ic,
3468 uint8_t *printed = av_mallocz(ic->nb_streams);
3469 if (ic->nb_streams && !printed)
3472 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3473 is_output ? "Output" : "Input",
3475 is_output ? ic->oformat->name : ic->iformat->name,
3476 is_output ? "to" : "from", url);
3477 dump_metadata(NULL, ic->metadata, " ");
3479 av_log(NULL, AV_LOG_INFO, " Duration: ");
3480 if (ic->duration != AV_NOPTS_VALUE) {
3481 int hours, mins, secs, us;
3482 secs = ic->duration / AV_TIME_BASE;
3483 us = ic->duration % AV_TIME_BASE;
3488 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3489 (100 * us) / AV_TIME_BASE);
3491 av_log(NULL, AV_LOG_INFO, "N/A");
3493 if (ic->start_time != AV_NOPTS_VALUE) {
3495 av_log(NULL, AV_LOG_INFO, ", start: ");
3496 secs = ic->start_time / AV_TIME_BASE;
3497 us = abs(ic->start_time % AV_TIME_BASE);
3498 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3499 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3501 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3503 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3505 av_log(NULL, AV_LOG_INFO, "N/A");
3507 av_log(NULL, AV_LOG_INFO, "\n");
3509 for (i = 0; i < ic->nb_chapters; i++) {
3510 AVChapter *ch = ic->chapters[i];
3511 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3512 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3513 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3515 dump_metadata(NULL, ch->metadata, " ");
3517 if(ic->nb_programs) {
3518 int j, k, total = 0;
3519 for(j=0; j<ic->nb_programs; j++) {
3520 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3522 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3523 name ? name->value : "");
3524 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3525 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3526 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3527 printed[ic->programs[j]->stream_index[k]] = 1;
3529 total += ic->programs[j]->nb_stream_indexes;
3531 if (total < ic->nb_streams)
3532 av_log(NULL, AV_LOG_INFO, " No Program\n");
3534 for(i=0;i<ic->nb_streams;i++)
3536 dump_stream_format(ic, i, index, is_output);
3541 int64_t av_gettime(void)
3544 gettimeofday(&tv,NULL);
3545 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3548 uint64_t ff_ntp_time(void)
3550 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3553 #if FF_API_PARSE_DATE
3554 #include "libavutil/parseutils.h"
3556 int64_t parse_date(const char *timestr, int duration)
3559 av_parse_time(&timeval, timestr, duration);
3564 #if FF_API_FIND_INFO_TAG
3565 #include "libavutil/parseutils.h"
3567 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3569 return av_find_info_tag(arg, arg_size, tag1, info);
3573 int av_get_frame_filename(char *buf, int buf_size,
3574 const char *path, int number)
3577 char *q, buf1[20], c;
3578 int nd, len, percentd_found;
3590 while (isdigit(*p)) {
3591 nd = nd * 10 + *p++ - '0';
3594 } while (isdigit(c));
3603 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3605 if ((q - buf + len) > buf_size - 1)
3607 memcpy(q, buf1, len);
3615 if ((q - buf) < buf_size - 1)
3619 if (!percentd_found)
3628 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3632 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3634 for(i=0;i<size;i+=16) {
3641 PRINT(" %02x", buf[i+j]);
3646 for(j=0;j<len;j++) {
3648 if (c < ' ' || c > '~')
3657 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3659 hex_dump_internal(NULL, f, 0, buf, size);
3662 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3664 hex_dump_internal(avcl, NULL, level, buf, size);
3667 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3670 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3671 PRINT("stream #%d:\n", pkt->stream_index);
3672 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3673 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3674 /* DTS is _always_ valid after av_read_frame() */
3676 if (pkt->dts == AV_NOPTS_VALUE)
3679 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3680 /* PTS may not be known if B-frames are present. */
3682 if (pkt->pts == AV_NOPTS_VALUE)
3685 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3687 PRINT(" size=%d\n", pkt->size);
3690 av_hex_dump(f, pkt->data, pkt->size);
3694 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3696 AVRational tb = { 1, AV_TIME_BASE };
3697 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3701 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3703 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3707 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3709 AVRational tb = { 1, AV_TIME_BASE };
3710 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3714 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3717 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3720 void av_url_split(char *proto, int proto_size,
3721 char *authorization, int authorization_size,
3722 char *hostname, int hostname_size,
3724 char *path, int path_size,
3727 const char *p, *ls, *at, *col, *brk;
3729 if (port_ptr) *port_ptr = -1;
3730 if (proto_size > 0) proto[0] = 0;
3731 if (authorization_size > 0) authorization[0] = 0;
3732 if (hostname_size > 0) hostname[0] = 0;
3733 if (path_size > 0) path[0] = 0;
3735 /* parse protocol */
3736 if ((p = strchr(url, ':'))) {
3737 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3742 /* no protocol means plain filename */
3743 av_strlcpy(path, url, path_size);
3747 /* separate path from hostname */
3748 ls = strchr(p, '/');
3750 ls = strchr(p, '?');
3752 av_strlcpy(path, ls, path_size);
3754 ls = &p[strlen(p)]; // XXX
3756 /* the rest is hostname, use that to parse auth/port */
3758 /* authorization (user[:pass]@hostname) */
3759 if ((at = strchr(p, '@')) && at < ls) {
3760 av_strlcpy(authorization, p,
3761 FFMIN(authorization_size, at + 1 - p));
3762 p = at + 1; /* skip '@' */
3765 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3767 av_strlcpy(hostname, p + 1,
3768 FFMIN(hostname_size, brk - p));
3769 if (brk[1] == ':' && port_ptr)
3770 *port_ptr = atoi(brk + 2);
3771 } else if ((col = strchr(p, ':')) && col < ls) {
3772 av_strlcpy(hostname, p,
3773 FFMIN(col + 1 - p, hostname_size));
3774 if (port_ptr) *port_ptr = atoi(col + 1);
3776 av_strlcpy(hostname, p,
3777 FFMIN(ls + 1 - p, hostname_size));
3781 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3784 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3787 'C', 'D', 'E', 'F' };
3788 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3791 'c', 'd', 'e', 'f' };
3792 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3794 for(i = 0; i < s; i++) {
3795 buff[i * 2] = hex_table[src[i] >> 4];
3796 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3802 int ff_hex_to_data(uint8_t *data, const char *p)
3809 p += strspn(p, SPACE_CHARS);
3812 c = toupper((unsigned char) *p++);
3813 if (c >= '0' && c <= '9')
3815 else if (c >= 'A' && c <= 'F')
3830 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3831 unsigned int pts_num, unsigned int pts_den)
3834 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3835 if(new_tb.num != pts_num)
3836 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3838 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3840 if(new_tb.num <= 0 || new_tb.den <= 0) {
3841 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3844 s->time_base = new_tb;
3845 s->pts_wrap_bits = pts_wrap_bits;
3848 int ff_url_join(char *str, int size, const char *proto,
3849 const char *authorization, const char *hostname,
3850 int port, const char *fmt, ...)
3853 struct addrinfo hints, *ai;
3858 av_strlcatf(str, size, "%s://", proto);
3859 if (authorization && authorization[0])
3860 av_strlcatf(str, size, "%s@", authorization);
3861 #if CONFIG_NETWORK && defined(AF_INET6)
3862 /* Determine if hostname is a numerical IPv6 address,
3863 * properly escape it within [] in that case. */
3864 memset(&hints, 0, sizeof(hints));
3865 hints.ai_flags = AI_NUMERICHOST;
3866 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3867 if (ai->ai_family == AF_INET6) {
3868 av_strlcat(str, "[", size);
3869 av_strlcat(str, hostname, size);
3870 av_strlcat(str, "]", size);
3872 av_strlcat(str, hostname, size);
3877 /* Not an IPv6 address, just output the plain string. */
3878 av_strlcat(str, hostname, size);
3881 av_strlcatf(str, size, ":%d", port);
3884 int len = strlen(str);
3887 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3893 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3894 AVFormatContext *src)
3899 local_pkt.stream_index = dst_stream;
3900 if (pkt->pts != AV_NOPTS_VALUE)
3901 local_pkt.pts = av_rescale_q(pkt->pts,
3902 src->streams[pkt->stream_index]->time_base,
3903 dst->streams[dst_stream]->time_base);
3904 if (pkt->dts != AV_NOPTS_VALUE)
3905 local_pkt.dts = av_rescale_q(pkt->dts,
3906 src->streams[pkt->stream_index]->time_base,
3907 dst->streams[dst_stream]->time_base);
3908 return av_write_frame(dst, &local_pkt);
3911 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3914 const char *ptr = str;
3916 /* Parse key=value pairs. */
3919 char *dest = NULL, *dest_end;
3920 int key_len, dest_len = 0;
3922 /* Skip whitespace and potential commas. */
3923 while (*ptr && (isspace(*ptr) || *ptr == ','))
3930 if (!(ptr = strchr(key, '=')))
3933 key_len = ptr - key;
3935 callback_get_buf(context, key, key_len, &dest, &dest_len);
3936 dest_end = dest + dest_len - 1;
3940 while (*ptr && *ptr != '\"') {
3944 if (dest && dest < dest_end)
3948 if (dest && dest < dest_end)
3956 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3957 if (dest && dest < dest_end)
3965 int ff_find_stream_index(AVFormatContext *s, int id)
3968 for (i = 0; i < s->nb_streams; i++) {
3969 if (s->streams[i]->id == id)
3975 void ff_make_absolute_url(char *buf, int size, const char *base,
3979 /* Absolute path, relative to the current server */
3980 if (base && strstr(base, "://") && rel[0] == '/') {
3982 av_strlcpy(buf, base, size);
3983 sep = strstr(buf, "://");
3986 sep = strchr(sep, '/');
3990 av_strlcat(buf, rel, size);
3993 /* If rel actually is an absolute url, just copy it */
3994 if (!base || strstr(rel, "://") || rel[0] == '/') {
3995 av_strlcpy(buf, rel, size);
3999 av_strlcpy(buf, base, size);
4000 /* Remove the file name from the base url */
4001 sep = strrchr(buf, '/');
4006 while (av_strstart(rel, "../", NULL) && sep) {
4007 /* Remove the path delimiter at the end */
4009 sep = strrchr(buf, '/');
4010 /* If the next directory name to pop off is "..", break here */
4011 if (!strcmp(sep ? &sep[1] : buf, "..")) {
4012 /* Readd the slash we just removed */
4013 av_strlcat(buf, "/", size);
4016 /* Cut off the directory name */
4023 av_strlcat(buf, rel, size);
4026 int64_t ff_iso8601_to_unix_time(const char *datestr)
4029 struct tm time = {0};
4030 strptime(datestr, "%Y - %m - %dT%T", &time);
4031 return mktime(&time);
4033 av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
4034 "the date string.\n");
4039 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
4042 if (ofmt->query_codec)
4043 return ofmt->query_codec(codec_id, std_compliance);
4044 else if (ofmt->codec_tag)
4045 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4046 else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4047 codec_id == ofmt->subtitle_codec)
4050 return AVERROR_PATCHWELCOME;