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"
36 #include "libavutil/parseutils.h"
38 #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 (!av_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 (!av_strncasecmp(name, names, len))
198 return !av_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, nodat = 0, 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;
324 while ((fmt1 = av_iformat_next(fmt1))) {
325 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
328 if (fmt1->read_probe) {
329 score = fmt1->read_probe(&lpd);
330 if(fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions))
331 score = FFMAX(score, nodat ? AVPROBE_SCORE_MAX/4-1 : 1);
332 } else if (fmt1->extensions) {
333 if (av_match_ext(lpd.filename, fmt1->extensions)) {
337 if (score > score_max) {
340 }else if (score == score_max)
343 *score_ret= score_max;
348 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
351 AVInputFormat *fmt= av_probe_input_format3(pd, is_opened, &score_ret);
352 if(score_ret > *score_max){
353 *score_max= score_ret;
359 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
361 return av_probe_input_format2(pd, is_opened, &score);
364 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd)
366 static const struct {
367 const char *name; enum CodecID id; enum AVMediaType type;
369 { "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
370 { "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
371 { "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
372 { "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
373 { "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
374 { "loas" , CODEC_ID_AAC_LATM , AVMEDIA_TYPE_AUDIO },
375 { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
376 { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
377 { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
381 AVInputFormat *fmt = av_probe_input_format3(pd, 1, &score);
385 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
386 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
387 for (i = 0; fmt_id_type[i].name; i++) {
388 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
389 st->codec->codec_id = fmt_id_type[i].id;
390 st->codec->codec_type = fmt_id_type[i].type;
398 /************************************************************/
399 /* input media file */
401 #if FF_API_FORMAT_PARAMETERS
402 static AVDictionary *convert_format_parameters(AVFormatParameters *ap)
405 AVDictionary *opts = NULL;
410 AV_NOWARN_DEPRECATED(
411 if (ap->time_base.num) {
412 snprintf(buf, sizeof(buf), "%d/%d", ap->time_base.den, ap->time_base.num);
413 av_dict_set(&opts, "framerate", buf, 0);
415 if (ap->sample_rate) {
416 snprintf(buf, sizeof(buf), "%d", ap->sample_rate);
417 av_dict_set(&opts, "sample_rate", buf, 0);
420 snprintf(buf, sizeof(buf), "%d", ap->channels);
421 av_dict_set(&opts, "channels", buf, 0);
423 if (ap->width || ap->height) {
424 snprintf(buf, sizeof(buf), "%dx%d", ap->width, ap->height);
425 av_dict_set(&opts, "video_size", buf, 0);
427 if (ap->pix_fmt != PIX_FMT_NONE) {
428 av_dict_set(&opts, "pixel_format", av_get_pix_fmt_name(ap->pix_fmt), 0);
431 snprintf(buf, sizeof(buf), "%d", ap->channel);
432 av_dict_set(&opts, "channel", buf, 0);
435 av_dict_set(&opts, "standard", ap->standard, 0);
437 if (ap->mpeg2ts_compute_pcr) {
438 av_dict_set(&opts, "mpeg2ts_compute_pcr", "1", 0);
440 if (ap->initial_pause) {
441 av_dict_set(&opts, "initial_pause", "1", 0);
448 * Open a media file from an IO stream. 'fmt' must be specified.
450 int av_open_input_stream(AVFormatContext **ic_ptr,
451 AVIOContext *pb, const char *filename,
452 AVInputFormat *fmt, AVFormatParameters *ap)
457 AVFormatParameters default_ap;
461 memset(ap, 0, sizeof(default_ap));
463 opts = convert_format_parameters(ap);
465 AV_NOWARN_DEPRECATED(
466 if(!ap->prealloced_context)
467 *ic_ptr = ic = avformat_alloc_context();
472 err = AVERROR(ENOMEM);
475 if (pb && fmt && fmt->flags & AVFMT_NOFILE)
476 av_log(ic, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
477 "will be ignored with AVFMT_NOFILE format.\n");
481 if ((err = avformat_open_input(&ic, filename, fmt, &opts)) < 0)
483 ic->pb = ic->pb ? ic->pb : pb; // don't leak custom pb if it wasn't set above
492 int av_demuxer_open(AVFormatContext *ic, AVFormatParameters *ap){
495 if (ic->iformat->read_header) {
496 err = ic->iformat->read_header(ic, ap);
501 if (ic->pb && !ic->data_offset)
502 ic->data_offset = avio_tell(ic->pb);
508 /** size of probe buffer, for guessing file type from file contents */
509 #define PROBE_BUF_MIN 2048
510 #define PROBE_BUF_MAX (1<<20)
512 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
513 const char *filename, void *logctx,
514 unsigned int offset, unsigned int max_probe_size)
516 AVProbeData pd = { filename ? filename : "", NULL, -offset };
517 unsigned char *buf = NULL;
518 int ret = 0, probe_size;
520 if (!max_probe_size) {
521 max_probe_size = PROBE_BUF_MAX;
522 } else if (max_probe_size > PROBE_BUF_MAX) {
523 max_probe_size = PROBE_BUF_MAX;
524 } else if (max_probe_size < PROBE_BUF_MIN) {
525 return AVERROR(EINVAL);
528 if (offset >= max_probe_size) {
529 return AVERROR(EINVAL);
532 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt;
533 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
534 int score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
535 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
538 if (probe_size < offset) {
542 /* read probe data */
543 buftmp = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
546 return AVERROR(ENOMEM);
549 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
550 /* fail if error was not end of file, otherwise, lower score */
551 if (ret != AVERROR_EOF) {
556 ret = 0; /* error was end of file, nothing read */
559 pd.buf = &buf[offset];
561 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
563 /* guess file format */
564 *fmt = av_probe_input_format2(&pd, 1, &score);
566 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
567 av_log(logctx, AV_LOG_WARNING, "Format %s detected only with low score of %d, misdetection possible!\n", (*fmt)->name, score);
569 av_log(logctx, AV_LOG_DEBUG, "Format %s probed with size=%d and score=%d\n", (*fmt)->name, probe_size, score);
575 return AVERROR_INVALIDDATA;
578 /* rewind. reuse probe buffer to avoid seeking */
579 if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
585 #if FF_API_FORMAT_PARAMETERS
586 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
589 AVFormatParameters *ap)
592 AVDictionary *opts = convert_format_parameters(ap);
594 AV_NOWARN_DEPRECATED(
595 if (!ap || !ap->prealloced_context)
599 err = avformat_open_input(ic_ptr, filename, fmt, &opts);
606 /* open input file and probe the format if necessary */
607 static int init_input(AVFormatContext *s, const char *filename, AVDictionary **options)
610 AVProbeData pd = {filename, NULL, 0};
612 if(s->iformat && !strlen(filename))
616 s->flags |= AVFMT_FLAG_CUSTOM_IO;
618 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
619 else if (s->iformat->flags & AVFMT_NOFILE)
620 av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
621 "will be ignored with AVFMT_NOFILE format.\n");
625 if ( (s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
626 (!s->iformat && (s->iformat = av_probe_input_format(&pd, 0))))
629 if ((ret = avio_open2(&s->pb, filename, AVIO_FLAG_READ,
630 &s->interrupt_callback, options)) < 0)
634 return av_probe_input_buffer(s->pb, &s->iformat, filename, s, 0, 0);
637 int avformat_open_input(AVFormatContext **ps, const char *filename, AVInputFormat *fmt, AVDictionary **options)
639 AVFormatContext *s = *ps;
641 AVFormatParameters ap = { { 0 } };
642 AVDictionary *tmp = NULL;
644 if (!s && !(s = avformat_alloc_context()))
645 return AVERROR(ENOMEM);
650 av_dict_copy(&tmp, *options, 0);
652 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
655 if ((ret = init_input(s, filename, &tmp)) < 0)
658 /* check filename in case an image number is expected */
659 if (s->iformat->flags & AVFMT_NEEDNUMBER) {
660 if (!av_filename_number_test(filename)) {
661 ret = AVERROR(EINVAL);
666 s->duration = s->start_time = AV_NOPTS_VALUE;
667 av_strlcpy(s->filename, filename, sizeof(s->filename));
669 /* allocate private data */
670 if (s->iformat->priv_data_size > 0) {
671 if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) {
672 ret = AVERROR(ENOMEM);
675 if (s->iformat->priv_class) {
676 *(const AVClass**)s->priv_data = s->iformat->priv_class;
677 av_opt_set_defaults(s->priv_data);
678 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
683 /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
685 ff_id3v2_read(s, ID3v2_DEFAULT_MAGIC);
687 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
688 if ((ret = s->iformat->read_header(s, &ap)) < 0)
691 if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->data_offset)
692 s->data_offset = avio_tell(s->pb);
694 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
697 av_dict_free(options);
705 if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
707 avformat_free_context(s);
712 /*******************************************************/
714 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
715 AVPacketList **plast_pktl){
716 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
721 (*plast_pktl)->next = pktl;
723 *packet_buffer = pktl;
725 /* add the packet in the buffered packet list */
731 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
737 AVPacketList *pktl = s->raw_packet_buffer;
741 if(s->streams[pkt->stream_index]->request_probe <= 0){
742 s->raw_packet_buffer = pktl->next;
743 s->raw_packet_buffer_remaining_size += pkt->size;
750 ret= s->iformat->read_packet(s, pkt);
752 if (!pktl || ret == AVERROR(EAGAIN))
754 for (i = 0; i < s->nb_streams; i++)
755 if(s->streams[i]->request_probe > 0)
756 s->streams[i]->request_probe = -1;
760 if ((s->flags & AVFMT_FLAG_DISCARD_CORRUPT) &&
761 (pkt->flags & AV_PKT_FLAG_CORRUPT)) {
762 av_log(s, AV_LOG_WARNING,
763 "Dropped corrupted packet (stream = %d)\n",
769 if(!(s->flags & AVFMT_FLAG_KEEP_SIDE_DATA))
770 av_packet_merge_side_data(pkt);
772 if(pkt->stream_index >= (unsigned)s->nb_streams){
773 av_log(s, AV_LOG_ERROR, "Invalid stream index %d\n", pkt->stream_index);
777 st= s->streams[pkt->stream_index];
779 switch(st->codec->codec_type){
780 case AVMEDIA_TYPE_VIDEO:
781 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
783 case AVMEDIA_TYPE_AUDIO:
784 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
786 case AVMEDIA_TYPE_SUBTITLE:
787 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
791 if(!pktl && st->request_probe <= 0)
794 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
795 s->raw_packet_buffer_remaining_size -= pkt->size;
797 if(st->request_probe>0){
798 AVProbeData *pd = &st->probe_data;
800 av_log(s, AV_LOG_DEBUG, "probing stream %d pp:%d\n", st->index, st->probe_packets);
803 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
804 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
805 pd->buf_size += pkt->size;
806 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
808 end= s->raw_packet_buffer_remaining_size <= 0
809 || st->probe_packets<=0;
811 if(end || av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
812 int score= set_codec_from_probe_data(s, st, pd);
813 if( (st->codec->codec_id != CODEC_ID_NONE && score > AVPROBE_SCORE_MAX/4)
817 st->request_probe= -1;
818 if(st->codec->codec_id != CODEC_ID_NONE){
819 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
821 av_log(s, AV_LOG_WARNING, "probed stream %d failed\n", st->index);
828 /**********************************************************/
831 * Get the number of samples of an audio frame. Return -1 on error.
833 static int get_audio_frame_size(AVCodecContext *enc, int size)
837 if(enc->codec_id == CODEC_ID_VORBIS)
840 if (enc->frame_size <= 1) {
841 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
843 if (bits_per_sample) {
844 if (enc->channels == 0)
846 frame_size = (size << 3) / (bits_per_sample * enc->channels);
848 /* used for example by ADPCM codecs */
849 if (enc->bit_rate == 0)
851 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
854 frame_size = enc->frame_size;
861 * Return the frame duration in seconds. Return 0 if not available.
863 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
864 AVCodecParserContext *pc, AVPacket *pkt)
870 switch(st->codec->codec_type) {
871 case AVMEDIA_TYPE_VIDEO:
872 if(st->time_base.num*1000LL > st->time_base.den){
873 *pnum = st->time_base.num;
874 *pden = st->time_base.den;
875 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
876 *pnum = st->codec->time_base.num;
877 *pden = st->codec->time_base.den;
878 if (pc && pc->repeat_pict) {
879 *pnum = (*pnum) * (1 + pc->repeat_pict);
881 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
882 //Thus if we have no parser in such case leave duration undefined.
883 if(st->codec->ticks_per_frame>1 && !pc){
888 case AVMEDIA_TYPE_AUDIO:
889 frame_size = get_audio_frame_size(st->codec, pkt->size);
890 if (frame_size <= 0 || st->codec->sample_rate <= 0)
893 *pden = st->codec->sample_rate;
900 static int is_intra_only(AVCodecContext *enc){
901 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
903 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
904 switch(enc->codec_id){
906 case CODEC_ID_MJPEGB:
908 case CODEC_ID_PRORES:
909 case CODEC_ID_RAWVIDEO:
910 case CODEC_ID_DVVIDEO:
911 case CODEC_ID_HUFFYUV:
912 case CODEC_ID_FFVHUFF:
917 case CODEC_ID_JPEG2000:
925 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
926 int64_t dts, int64_t pts)
928 AVStream *st= s->streams[stream_index];
929 AVPacketList *pktl= s->packet_buffer;
931 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
934 st->first_dts= dts - st->cur_dts;
937 for(; pktl; pktl= pktl->next){
938 if(pktl->pkt.stream_index != stream_index)
940 //FIXME think more about this check
941 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
942 pktl->pkt.pts += st->first_dts;
944 if(pktl->pkt.dts != AV_NOPTS_VALUE)
945 pktl->pkt.dts += st->first_dts;
947 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
948 st->start_time= pktl->pkt.pts;
950 if (st->start_time == AV_NOPTS_VALUE)
951 st->start_time = pts;
954 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
956 AVPacketList *pktl= s->packet_buffer;
959 if(st->first_dts != AV_NOPTS_VALUE){
960 cur_dts= st->first_dts;
961 for(; pktl; pktl= pktl->next){
962 if(pktl->pkt.stream_index == pkt->stream_index){
963 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
965 cur_dts -= pkt->duration;
968 pktl= s->packet_buffer;
969 st->first_dts = cur_dts;
970 }else if(st->cur_dts)
973 for(; pktl; pktl= pktl->next){
974 if(pktl->pkt.stream_index != pkt->stream_index)
976 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
977 && !pktl->pkt.duration){
978 pktl->pkt.dts= cur_dts;
979 if(!st->codec->has_b_frames)
980 pktl->pkt.pts= cur_dts;
981 cur_dts += pkt->duration;
982 pktl->pkt.duration= pkt->duration;
986 if(st->first_dts == AV_NOPTS_VALUE)
987 st->cur_dts= cur_dts;
990 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
991 AVCodecParserContext *pc, AVPacket *pkt)
993 int num, den, presentation_delayed, delay, i;
996 if (s->flags & AVFMT_FLAG_NOFILLIN)
999 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
1000 pkt->dts= AV_NOPTS_VALUE;
1002 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == AV_PICTURE_TYPE_B)
1003 //FIXME Set low_delay = 0 when has_b_frames = 1
1004 st->codec->has_b_frames = 1;
1006 /* do we have a video B-frame ? */
1007 delay= st->codec->has_b_frames;
1008 presentation_delayed = 0;
1010 /* XXX: need has_b_frame, but cannot get it if the codec is
1013 pc && pc->pict_type != AV_PICTURE_TYPE_B)
1014 presentation_delayed = 1;
1016 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts - (1LL<<(st->pts_wrap_bits-1)) > pkt->pts && st->pts_wrap_bits<63){
1017 pkt->dts -= 1LL<<st->pts_wrap_bits;
1020 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
1021 // we take the conservative approach and discard both
1022 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
1023 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
1024 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination %"PRIi64"\n", pkt->dts);
1025 pkt->dts= AV_NOPTS_VALUE;
1028 if (pkt->duration == 0) {
1029 compute_frame_duration(&num, &den, st, pc, pkt);
1031 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
1033 if(pkt->duration != 0 && s->packet_buffer)
1034 update_initial_durations(s, st, pkt);
1038 /* correct timestamps with byte offset if demuxers only have timestamps
1039 on packet boundaries */
1040 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
1041 /* this will estimate bitrate based on this frame's duration and size */
1042 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
1043 if(pkt->pts != AV_NOPTS_VALUE)
1045 if(pkt->dts != AV_NOPTS_VALUE)
1049 if (pc && pc->dts_sync_point >= 0) {
1050 // we have synchronization info from the parser
1051 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
1053 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
1054 if (pkt->dts != AV_NOPTS_VALUE) {
1055 // got DTS from the stream, update reference timestamp
1056 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
1057 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1058 } else if (st->reference_dts != AV_NOPTS_VALUE) {
1059 // compute DTS based on reference timestamp
1060 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
1061 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
1063 if (pc->dts_sync_point > 0)
1064 st->reference_dts = pkt->dts; // new reference
1068 /* This may be redundant, but it should not hurt. */
1069 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1070 presentation_delayed = 1;
1072 // 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);
1073 /* interpolate PTS and DTS if they are not present */
1074 //We skip H264 currently because delay and has_b_frames are not reliably set
1075 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1076 if (presentation_delayed) {
1077 /* DTS = decompression timestamp */
1078 /* PTS = presentation timestamp */
1079 if (pkt->dts == AV_NOPTS_VALUE)
1080 pkt->dts = st->last_IP_pts;
1081 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1082 if (pkt->dts == AV_NOPTS_VALUE)
1083 pkt->dts = st->cur_dts;
1085 /* this is tricky: the dts must be incremented by the duration
1086 of the frame we are displaying, i.e. the last I- or P-frame */
1087 if (st->last_IP_duration == 0)
1088 st->last_IP_duration = pkt->duration;
1089 if(pkt->dts != AV_NOPTS_VALUE)
1090 st->cur_dts = pkt->dts + st->last_IP_duration;
1091 st->last_IP_duration = pkt->duration;
1092 st->last_IP_pts= pkt->pts;
1093 /* cannot compute PTS if not present (we can compute it only
1094 by knowing the future */
1095 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1096 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1097 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1098 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1099 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1100 pkt->pts += pkt->duration;
1101 // 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);
1105 /* presentation is not delayed : PTS and DTS are the same */
1106 if(pkt->pts == AV_NOPTS_VALUE)
1107 pkt->pts = pkt->dts;
1108 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1109 if(pkt->pts == AV_NOPTS_VALUE)
1110 pkt->pts = st->cur_dts;
1111 pkt->dts = pkt->pts;
1112 if(pkt->pts != AV_NOPTS_VALUE)
1113 st->cur_dts = pkt->pts + pkt->duration;
1117 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1118 st->pts_buffer[0]= pkt->pts;
1119 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1120 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1121 if(pkt->dts == AV_NOPTS_VALUE)
1122 pkt->dts= st->pts_buffer[0];
1123 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1124 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1126 if(pkt->dts > st->cur_dts)
1127 st->cur_dts = pkt->dts;
1130 // 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);
1133 if(is_intra_only(st->codec))
1134 pkt->flags |= AV_PKT_FLAG_KEY;
1137 /* keyframe computation */
1138 if (pc->key_frame == 1)
1139 pkt->flags |= AV_PKT_FLAG_KEY;
1140 else if (pc->key_frame == -1 && pc->pict_type == AV_PICTURE_TYPE_I)
1141 pkt->flags |= AV_PKT_FLAG_KEY;
1144 pkt->convergence_duration = pc->convergence_duration;
1148 static int read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1153 av_init_packet(pkt);
1156 /* select current input stream component */
1159 if (!st->need_parsing || !st->parser) {
1160 /* no parsing needed: we just output the packet as is */
1161 /* raw data support */
1163 st->cur_pkt.data= NULL;
1164 st->cur_pkt.side_data_elems = 0;
1165 st->cur_pkt.side_data = NULL;
1166 compute_pkt_fields(s, st, NULL, pkt);
1168 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1169 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1170 ff_reduce_index(s, st->index);
1171 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1174 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1175 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1176 st->cur_ptr, st->cur_len,
1177 st->cur_pkt.pts, st->cur_pkt.dts,
1179 st->cur_pkt.pts = AV_NOPTS_VALUE;
1180 st->cur_pkt.dts = AV_NOPTS_VALUE;
1181 /* increment read pointer */
1185 /* return packet if any */
1189 pkt->stream_index = st->index;
1190 pkt->pts = st->parser->pts;
1191 pkt->dts = st->parser->dts;
1192 pkt->pos = st->parser->pos;
1193 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1195 pkt->destruct= st->cur_pkt.destruct;
1196 st->cur_pkt.destruct= NULL;
1197 st->cur_pkt.data = NULL;
1198 assert(st->cur_len == 0);
1200 pkt->destruct = NULL;
1202 compute_pkt_fields(s, st, st->parser, pkt);
1204 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1205 int64_t pos= (st->parser->flags & PARSER_FLAG_COMPLETE_FRAMES) ? pkt->pos : st->parser->frame_offset;
1206 ff_reduce_index(s, st->index);
1207 av_add_index_entry(st, pos, pkt->dts,
1208 0, 0, AVINDEX_KEYFRAME);
1215 av_free_packet(&st->cur_pkt);
1220 /* read next packet */
1221 ret = av_read_packet(s, &cur_pkt);
1223 if (ret == AVERROR(EAGAIN))
1225 /* return the last frames, if any */
1226 for(i = 0; i < s->nb_streams; i++) {
1228 if (st->parser && st->need_parsing) {
1229 av_parser_parse2(st->parser, st->codec,
1230 &pkt->data, &pkt->size,
1232 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1238 /* no more packets: really terminate parsing */
1241 st = s->streams[cur_pkt.stream_index];
1242 st->cur_pkt= cur_pkt;
1244 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1245 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1246 st->cur_pkt.pts < st->cur_pkt.dts){
1247 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1248 st->cur_pkt.stream_index,
1252 // av_free_packet(&st->cur_pkt);
1256 if(s->debug & FF_FDEBUG_TS)
1257 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1258 st->cur_pkt.stream_index,
1262 st->cur_pkt.duration,
1266 st->cur_ptr = st->cur_pkt.data;
1267 st->cur_len = st->cur_pkt.size;
1268 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1269 st->parser = av_parser_init(st->codec->codec_id);
1271 av_log(s, AV_LOG_WARNING, "parser not found for codec "
1272 "%s, packets or times may be invalid.\n",
1273 avcodec_get_name(st->codec->codec_id));
1274 /* no parser available: just output the raw packets */
1275 st->need_parsing = AVSTREAM_PARSE_NONE;
1276 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1277 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1278 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1279 st->parser->flags |= PARSER_FLAG_ONCE;
1284 if(s->debug & FF_FDEBUG_TS)
1285 av_log(s, AV_LOG_DEBUG, "read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1296 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1300 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1303 pktl = s->packet_buffer;
1305 AVPacket *next_pkt= &pktl->pkt;
1307 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1308 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1309 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1310 if( pktl->pkt.stream_index == next_pkt->stream_index
1311 && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1312 && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1313 next_pkt->pts= pktl->pkt.dts;
1317 pktl = s->packet_buffer;
1320 if( next_pkt->pts != AV_NOPTS_VALUE
1321 || next_pkt->dts == AV_NOPTS_VALUE
1323 /* read packet from packet buffer, if there is data */
1325 s->packet_buffer = pktl->next;
1331 int ret= read_frame_internal(s, pkt);
1333 if(pktl && ret != AVERROR(EAGAIN)){
1340 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1341 &s->packet_buffer_end)) < 0)
1342 return AVERROR(ENOMEM);
1344 assert(!s->packet_buffer);
1345 return read_frame_internal(s, pkt);
1350 /* XXX: suppress the packet queue */
1351 static void flush_packet_queue(AVFormatContext *s)
1356 pktl = s->packet_buffer;
1359 s->packet_buffer = pktl->next;
1360 av_free_packet(&pktl->pkt);
1363 while(s->raw_packet_buffer){
1364 pktl = s->raw_packet_buffer;
1365 s->raw_packet_buffer = pktl->next;
1366 av_free_packet(&pktl->pkt);
1369 s->packet_buffer_end=
1370 s->raw_packet_buffer_end= NULL;
1371 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1374 /*******************************************************/
1377 int av_find_default_stream_index(AVFormatContext *s)
1379 int first_audio_index = -1;
1383 if (s->nb_streams <= 0)
1385 for(i = 0; i < s->nb_streams; i++) {
1387 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1390 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1391 first_audio_index = i;
1393 return first_audio_index >= 0 ? first_audio_index : 0;
1397 * Flush the frame reader.
1399 void ff_read_frame_flush(AVFormatContext *s)
1404 flush_packet_queue(s);
1408 /* for each stream, reset read state */
1409 for(i = 0; i < s->nb_streams; i++) {
1413 av_parser_close(st->parser);
1415 av_free_packet(&st->cur_pkt);
1417 st->last_IP_pts = AV_NOPTS_VALUE;
1418 if(st->first_dts == AV_NOPTS_VALUE) st->cur_dts = 0;
1419 else st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1420 st->reference_dts = AV_NOPTS_VALUE;
1425 st->probe_packets = MAX_PROBE_PACKETS;
1427 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1428 st->pts_buffer[j]= AV_NOPTS_VALUE;
1432 #if FF_API_SEEK_PUBLIC
1433 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1435 ff_update_cur_dts(s, ref_st, timestamp);
1439 void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
1443 for(i = 0; i < s->nb_streams; i++) {
1444 AVStream *st = s->streams[i];
1446 st->cur_dts = av_rescale(timestamp,
1447 st->time_base.den * (int64_t)ref_st->time_base.num,
1448 st->time_base.num * (int64_t)ref_st->time_base.den);
1452 void ff_reduce_index(AVFormatContext *s, int stream_index)
1454 AVStream *st= s->streams[stream_index];
1455 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1457 if((unsigned)st->nb_index_entries >= max_entries){
1459 for(i=0; 2*i<st->nb_index_entries; i++)
1460 st->index_entries[i]= st->index_entries[2*i];
1461 st->nb_index_entries= i;
1465 int ff_add_index_entry(AVIndexEntry **index_entries,
1466 int *nb_index_entries,
1467 unsigned int *index_entries_allocated_size,
1468 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1470 AVIndexEntry *entries, *ie;
1473 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1476 entries = av_fast_realloc(*index_entries,
1477 index_entries_allocated_size,
1478 (*nb_index_entries + 1) *
1479 sizeof(AVIndexEntry));
1483 *index_entries= entries;
1485 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1488 index= (*nb_index_entries)++;
1489 ie= &entries[index];
1490 assert(index==0 || ie[-1].timestamp < timestamp);
1492 ie= &entries[index];
1493 if(ie->timestamp != timestamp){
1494 if(ie->timestamp <= timestamp)
1496 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1497 (*nb_index_entries)++;
1498 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1499 distance= ie->min_distance;
1503 ie->timestamp = timestamp;
1504 ie->min_distance= distance;
1511 int av_add_index_entry(AVStream *st,
1512 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1514 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1515 &st->index_entries_allocated_size, pos,
1516 timestamp, size, distance, flags);
1519 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1520 int64_t wanted_timestamp, int flags)
1528 //optimize appending index entries at the end
1529 if(b && entries[b-1].timestamp < wanted_timestamp)
1534 timestamp = entries[m].timestamp;
1535 if(timestamp >= wanted_timestamp)
1537 if(timestamp <= wanted_timestamp)
1540 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1542 if(!(flags & AVSEEK_FLAG_ANY)){
1543 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1544 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1553 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1556 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1557 wanted_timestamp, flags);
1560 #if FF_API_SEEK_PUBLIC
1561 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1562 return ff_seek_frame_binary(s, stream_index, target_ts, flags);
1566 int ff_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags)
1568 AVInputFormat *avif= s->iformat;
1569 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1570 int64_t ts_min, ts_max, ts;
1575 if (stream_index < 0)
1578 av_dlog(s, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1581 ts_min= AV_NOPTS_VALUE;
1582 pos_limit= -1; //gcc falsely says it may be uninitialized
1584 st= s->streams[stream_index];
1585 if(st->index_entries){
1588 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()
1589 index= FFMAX(index, 0);
1590 e= &st->index_entries[index];
1592 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1594 ts_min= e->timestamp;
1595 av_dlog(s, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1601 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1602 assert(index < st->nb_index_entries);
1604 e= &st->index_entries[index];
1605 assert(e->timestamp >= target_ts);
1607 ts_max= e->timestamp;
1608 pos_limit= pos_max - e->min_distance;
1609 av_dlog(s, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1610 pos_max,pos_limit, ts_max);
1614 pos= ff_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1619 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1622 ff_read_frame_flush(s);
1623 ff_update_cur_dts(s, st, ts);
1628 #if FF_API_SEEK_PUBLIC
1629 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1630 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1631 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1632 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1634 return ff_gen_search(s, stream_index, target_ts, pos_min, pos_max,
1635 pos_limit, ts_min, ts_max, flags, ts_ret,
1640 int64_t ff_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts,
1641 int64_t pos_min, int64_t pos_max, int64_t pos_limit,
1642 int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret,
1643 int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t ))
1646 int64_t start_pos, filesize;
1649 av_dlog(s, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1651 if(ts_min == AV_NOPTS_VALUE){
1652 pos_min = s->data_offset;
1653 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1654 if (ts_min == AV_NOPTS_VALUE)
1658 if(ts_min >= target_ts){
1663 if(ts_max == AV_NOPTS_VALUE){
1665 filesize = avio_size(s->pb);
1666 pos_max = filesize - 1;
1669 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1671 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1672 if (ts_max == AV_NOPTS_VALUE)
1676 int64_t tmp_pos= pos_max + 1;
1677 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1678 if(tmp_ts == AV_NOPTS_VALUE)
1682 if(tmp_pos >= filesize)
1688 if(ts_max <= target_ts){
1693 if(ts_min > ts_max){
1695 }else if(ts_min == ts_max){
1700 while (pos_min < pos_limit) {
1701 av_dlog(s, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1702 pos_min, pos_max, ts_min, ts_max);
1703 assert(pos_limit <= pos_max);
1706 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1707 // interpolate position (better than dichotomy)
1708 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1709 + pos_min - approximate_keyframe_distance;
1710 }else if(no_change==1){
1711 // bisection, if interpolation failed to change min or max pos last time
1712 pos = (pos_min + pos_limit)>>1;
1714 /* linear search if bisection failed, can only happen if there
1715 are very few or no keyframes between min/max */
1720 else if(pos > pos_limit)
1724 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1729 av_dlog(s, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1730 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts,
1731 pos_limit, start_pos, no_change);
1732 if(ts == AV_NOPTS_VALUE){
1733 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1736 assert(ts != AV_NOPTS_VALUE);
1737 if (target_ts <= ts) {
1738 pos_limit = start_pos - 1;
1742 if (target_ts >= ts) {
1748 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1749 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1752 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1754 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1755 av_dlog(s, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1756 pos, ts_min, target_ts, ts_max);
1762 static int seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1763 int64_t pos_min, pos_max;
1767 if (stream_index < 0)
1770 st= s->streams[stream_index];
1773 pos_min = s->data_offset;
1774 pos_max = avio_size(s->pb) - 1;
1776 if (pos < pos_min) pos= pos_min;
1777 else if(pos > pos_max) pos= pos_max;
1779 avio_seek(s->pb, pos, SEEK_SET);
1782 av_update_cur_dts(s, st, ts);
1787 static int seek_frame_generic(AVFormatContext *s,
1788 int stream_index, int64_t timestamp, int flags)
1795 st = s->streams[stream_index];
1797 index = av_index_search_timestamp(st, timestamp, flags);
1799 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1802 if(index < 0 || index==st->nb_index_entries-1){
1806 if(st->nb_index_entries){
1807 assert(st->index_entries);
1808 ie= &st->index_entries[st->nb_index_entries-1];
1809 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1811 ff_update_cur_dts(s, st, ie->timestamp);
1813 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1819 read_status = av_read_frame(s, &pkt);
1820 } while (read_status == AVERROR(EAGAIN));
1821 if (read_status < 0)
1823 av_free_packet(&pkt);
1824 if(stream_index == pkt.stream_index && pkt.dts > timestamp){
1825 if(pkt.flags & AV_PKT_FLAG_KEY)
1827 if(nonkey++ > 1000 && st->codec->codec_id != CODEC_ID_CDGRAPHICS){
1828 av_log(s, AV_LOG_ERROR,"seek_frame_generic failed as this stream seems to contain no keyframes after the target timestamp, %d non keyframes found\n", nonkey);
1833 index = av_index_search_timestamp(st, timestamp, flags);
1838 ff_read_frame_flush(s);
1839 AV_NOWARN_DEPRECATED(
1840 if (s->iformat->read_seek){
1841 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1845 ie = &st->index_entries[index];
1846 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1848 ff_update_cur_dts(s, st, ie->timestamp);
1853 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1858 if (flags & AVSEEK_FLAG_BYTE) {
1859 if (s->iformat->flags & AVFMT_NO_BYTE_SEEK)
1861 ff_read_frame_flush(s);
1862 return seek_frame_byte(s, stream_index, timestamp, flags);
1865 if(stream_index < 0){
1866 stream_index= av_find_default_stream_index(s);
1867 if(stream_index < 0)
1870 st= s->streams[stream_index];
1871 /* timestamp for default must be expressed in AV_TIME_BASE units */
1872 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1875 /* first, we try the format specific seek */
1876 AV_NOWARN_DEPRECATED(
1877 if (s->iformat->read_seek) {
1878 ff_read_frame_flush(s);
1879 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1887 if (s->iformat->read_timestamp && !(s->iformat->flags & AVFMT_NOBINSEARCH)) {
1888 ff_read_frame_flush(s);
1889 return ff_seek_frame_binary(s, stream_index, timestamp, flags);
1890 } else if (!(s->iformat->flags & AVFMT_NOGENSEARCH)) {
1891 ff_read_frame_flush(s);
1892 return seek_frame_generic(s, stream_index, timestamp, flags);
1898 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1900 if(min_ts > ts || max_ts < ts)
1903 if (s->iformat->read_seek2) {
1904 ff_read_frame_flush(s);
1905 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1908 if(s->iformat->read_timestamp){
1909 //try to seek via read_timestamp()
1912 //Fallback to old API if new is not implemented but old is
1913 //Note the old has somewat different sematics
1914 AV_NOWARN_DEPRECATED(
1915 if(s->iformat->read_seek || 1)
1916 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1919 // try some generic seek like seek_frame_generic() but with new ts semantics
1922 /*******************************************************/
1925 * Return TRUE if the stream has accurate duration in any stream.
1927 * @return TRUE if the stream has accurate duration for at least one component.
1929 static int has_duration(AVFormatContext *ic)
1933 if(ic->duration != AV_NOPTS_VALUE)
1936 for(i = 0;i < ic->nb_streams; i++) {
1937 st = ic->streams[i];
1938 if (st->duration != AV_NOPTS_VALUE)
1945 * Estimate the stream timings from the one of each components.
1947 * Also computes the global bitrate if possible.
1949 static void update_stream_timings(AVFormatContext *ic)
1951 int64_t start_time, start_time1, start_time_text, end_time, end_time1;
1952 int64_t duration, duration1, filesize;
1956 start_time = INT64_MAX;
1957 start_time_text = INT64_MAX;
1958 end_time = INT64_MIN;
1959 duration = INT64_MIN;
1960 for(i = 0;i < ic->nb_streams; i++) {
1961 st = ic->streams[i];
1962 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1963 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1964 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1965 if (start_time1 < start_time_text)
1966 start_time_text = start_time1;
1968 start_time = FFMIN(start_time, start_time1);
1969 if (st->duration != AV_NOPTS_VALUE) {
1970 end_time1 = start_time1
1971 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1972 end_time = FFMAX(end_time, end_time1);
1975 if (st->duration != AV_NOPTS_VALUE) {
1976 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1977 duration = FFMAX(duration, duration1);
1980 if (start_time == INT64_MAX || (start_time > start_time_text && start_time - start_time_text < AV_TIME_BASE))
1981 start_time = start_time_text;
1982 if (start_time != INT64_MAX) {
1983 ic->start_time = start_time;
1984 if (end_time != INT64_MIN)
1985 duration = FFMAX(duration, end_time - start_time);
1987 if (duration != INT64_MIN && ic->duration == AV_NOPTS_VALUE) {
1988 ic->duration = duration;
1990 if (ic->pb && (filesize = avio_size(ic->pb)) > 0 && ic->duration != AV_NOPTS_VALUE) {
1991 /* compute the bitrate */
1992 ic->bit_rate = (double)filesize * 8.0 * AV_TIME_BASE /
1993 (double)ic->duration;
1997 static void fill_all_stream_timings(AVFormatContext *ic)
2002 update_stream_timings(ic);
2003 for(i = 0;i < ic->nb_streams; i++) {
2004 st = ic->streams[i];
2005 if (st->start_time == AV_NOPTS_VALUE) {
2006 if(ic->start_time != AV_NOPTS_VALUE)
2007 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
2008 if(ic->duration != AV_NOPTS_VALUE)
2009 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
2014 static void estimate_timings_from_bit_rate(AVFormatContext *ic)
2016 int64_t filesize, duration;
2020 /* if bit_rate is already set, we believe it */
2021 if (ic->bit_rate <= 0) {
2023 for(i=0;i<ic->nb_streams;i++) {
2024 st = ic->streams[i];
2025 if (st->codec->bit_rate > 0)
2026 bit_rate += st->codec->bit_rate;
2028 ic->bit_rate = bit_rate;
2031 /* if duration is already set, we believe it */
2032 if (ic->duration == AV_NOPTS_VALUE &&
2033 ic->bit_rate != 0) {
2034 filesize = ic->pb ? avio_size(ic->pb) : 0;
2036 for(i = 0; i < ic->nb_streams; i++) {
2037 st = ic->streams[i];
2038 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
2039 if (st->duration == AV_NOPTS_VALUE)
2040 st->duration = duration;
2046 #define DURATION_MAX_READ_SIZE 250000
2047 #define DURATION_MAX_RETRY 3
2049 /* only usable for MPEG-PS streams */
2050 static void estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
2052 AVPacket pkt1, *pkt = &pkt1;
2054 int read_size, i, ret;
2056 int64_t filesize, offset, duration;
2061 /* flush packet queue */
2062 flush_packet_queue(ic);
2064 for (i=0; i<ic->nb_streams; i++) {
2065 st = ic->streams[i];
2066 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
2067 av_log(st->codec, AV_LOG_WARNING, "start time is not set in estimate_timings_from_pts\n");
2070 av_parser_close(st->parser);
2072 av_free_packet(&st->cur_pkt);
2076 /* estimate the end time (duration) */
2077 /* XXX: may need to support wrapping */
2078 filesize = ic->pb ? avio_size(ic->pb) : 0;
2079 end_time = AV_NOPTS_VALUE;
2081 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
2085 avio_seek(ic->pb, offset, SEEK_SET);
2088 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
2092 ret = av_read_packet(ic, pkt);
2093 } while(ret == AVERROR(EAGAIN));
2096 read_size += pkt->size;
2097 st = ic->streams[pkt->stream_index];
2098 if (pkt->pts != AV_NOPTS_VALUE &&
2099 (st->start_time != AV_NOPTS_VALUE ||
2100 st->first_dts != AV_NOPTS_VALUE)) {
2101 duration = end_time = pkt->pts;
2102 if (st->start_time != AV_NOPTS_VALUE)
2103 duration -= st->start_time;
2105 duration -= st->first_dts;
2107 duration += 1LL<<st->pts_wrap_bits;
2109 if (st->duration == AV_NOPTS_VALUE || st->duration < duration)
2110 st->duration = duration;
2113 av_free_packet(pkt);
2115 }while( end_time==AV_NOPTS_VALUE
2116 && filesize > (DURATION_MAX_READ_SIZE<<retry)
2117 && ++retry <= DURATION_MAX_RETRY);
2119 fill_all_stream_timings(ic);
2121 avio_seek(ic->pb, old_offset, SEEK_SET);
2122 for (i=0; i<ic->nb_streams; i++) {
2124 st->cur_dts= st->first_dts;
2125 st->last_IP_pts = AV_NOPTS_VALUE;
2126 st->reference_dts = AV_NOPTS_VALUE;
2130 static void estimate_timings(AVFormatContext *ic, int64_t old_offset)
2134 /* get the file size, if possible */
2135 if (ic->iformat->flags & AVFMT_NOFILE) {
2138 file_size = avio_size(ic->pb);
2139 file_size = FFMAX(0, file_size);
2142 if ((!strcmp(ic->iformat->name, "mpeg") ||
2143 !strcmp(ic->iformat->name, "mpegts")) &&
2144 file_size && ic->pb->seekable) {
2145 /* get accurate estimate from the PTSes */
2146 estimate_timings_from_pts(ic, old_offset);
2147 } else if (has_duration(ic)) {
2148 /* at least one component has timings - we use them for all
2150 fill_all_stream_timings(ic);
2152 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2153 /* less precise: use bitrate info */
2154 estimate_timings_from_bit_rate(ic);
2156 update_stream_timings(ic);
2160 AVStream av_unused *st;
2161 for(i = 0;i < ic->nb_streams; i++) {
2162 st = ic->streams[i];
2163 av_dlog(ic, "%d: start_time: %0.3f duration: %0.3f\n", i,
2164 (double) st->start_time / AV_TIME_BASE,
2165 (double) st->duration / AV_TIME_BASE);
2167 av_dlog(ic, "stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2168 (double) ic->start_time / AV_TIME_BASE,
2169 (double) ic->duration / AV_TIME_BASE,
2170 ic->bit_rate / 1000);
2174 static int has_codec_parameters(AVCodecContext *avctx)
2177 switch (avctx->codec_type) {
2178 case AVMEDIA_TYPE_AUDIO:
2179 val = avctx->sample_rate && avctx->channels && avctx->sample_fmt != AV_SAMPLE_FMT_NONE;
2180 if (!avctx->frame_size &&
2181 (avctx->codec_id == CODEC_ID_VORBIS ||
2182 avctx->codec_id == CODEC_ID_AAC ||
2183 avctx->codec_id == CODEC_ID_MP1 ||
2184 avctx->codec_id == CODEC_ID_MP2 ||
2185 avctx->codec_id == CODEC_ID_MP3 ||
2186 avctx->codec_id == CODEC_ID_CELT))
2189 case AVMEDIA_TYPE_VIDEO:
2190 val = avctx->width && avctx->pix_fmt != PIX_FMT_NONE;
2192 case AVMEDIA_TYPE_DATA:
2193 if(avctx->codec_id == CODEC_ID_NONE) return 1;
2198 return avctx->codec_id != CODEC_ID_NONE && val != 0;
2201 static int has_decode_delay_been_guessed(AVStream *st)
2203 return st->codec->codec_id != CODEC_ID_H264 ||
2204 st->info->nb_decoded_frames >= 6;
2207 static int try_decode_frame(AVStream *st, AVPacket *avpkt, AVDictionary **options)
2211 int got_picture, data_size, ret=0;
2214 if(!st->codec->codec){
2215 codec = avcodec_find_decoder(st->codec->codec_id);
2218 ret = avcodec_open2(st->codec, codec, options);
2223 if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st) ||
2224 (!st->codec_info_nb_frames && st->codec->codec->capabilities & CODEC_CAP_CHANNEL_CONF)) {
2225 switch(st->codec->codec_type) {
2226 case AVMEDIA_TYPE_VIDEO:
2227 avcodec_get_frame_defaults(&picture);
2228 ret = avcodec_decode_video2(st->codec, &picture,
2229 &got_picture, avpkt);
2231 st->info->nb_decoded_frames++;
2233 case AVMEDIA_TYPE_AUDIO:
2234 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2235 samples = av_malloc(data_size);
2238 ret = avcodec_decode_audio3(st->codec, samples,
2250 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2252 while (tags->id != CODEC_ID_NONE) {
2260 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2263 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2264 if(tag == tags[i].tag)
2267 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2268 if (avpriv_toupper4(tag) == avpriv_toupper4(tags[i].tag))
2271 return CODEC_ID_NONE;
2274 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2277 for(i=0; tags && tags[i]; i++){
2278 int tag= ff_codec_get_tag(tags[i], id);
2284 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2287 for(i=0; tags && tags[i]; i++){
2288 enum CodecID id= ff_codec_get_id(tags[i], tag);
2289 if(id!=CODEC_ID_NONE) return id;
2291 return CODEC_ID_NONE;
2294 static void compute_chapters_end(AVFormatContext *s)
2297 int64_t max_time = s->duration + ((s->start_time == AV_NOPTS_VALUE) ? 0 : s->start_time);
2299 for (i = 0; i < s->nb_chapters; i++)
2300 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2301 AVChapter *ch = s->chapters[i];
2302 int64_t end = max_time ? av_rescale_q(max_time, AV_TIME_BASE_Q, ch->time_base)
2305 for (j = 0; j < s->nb_chapters; j++) {
2306 AVChapter *ch1 = s->chapters[j];
2307 int64_t next_start = av_rescale_q(ch1->start, ch1->time_base, ch->time_base);
2308 if (j != i && next_start > ch->start && next_start < end)
2311 ch->end = (end == INT64_MAX) ? ch->start : end;
2315 static int get_std_framerate(int i){
2316 if(i<60*12) return i*1001;
2317 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2321 * Is the time base unreliable.
2322 * This is a heuristic to balance between quick acceptance of the values in
2323 * the headers vs. some extra checks.
2324 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2325 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2326 * And there are "variable" fps files this needs to detect as well.
2328 static int tb_unreliable(AVCodecContext *c){
2329 if( c->time_base.den >= 101L*c->time_base.num
2330 || c->time_base.den < 5L*c->time_base.num
2331 /* || c->codec_tag == AV_RL32("DIVX")
2332 || c->codec_tag == AV_RL32("XVID")*/
2333 || c->codec_id == CODEC_ID_MPEG2VIDEO
2334 || c->codec_id == CODEC_ID_H264
2340 #if FF_API_FORMAT_PARAMETERS
2341 int av_find_stream_info(AVFormatContext *ic)
2343 return avformat_find_stream_info(ic, NULL);
2347 int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
2349 int i, count, ret, read_size, j;
2351 AVPacket pkt1, *pkt;
2352 int64_t old_offset = avio_tell(ic->pb);
2353 int orig_nb_streams = ic->nb_streams; // new streams might appear, no options for those
2355 for(i=0;i<ic->nb_streams;i++) {
2357 st = ic->streams[i];
2359 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2360 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2361 /* if(!st->time_base.num)
2363 if(!st->codec->time_base.num)
2364 st->codec->time_base= st->time_base;
2366 //only for the split stuff
2367 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2368 st->parser = av_parser_init(st->codec->codec_id);
2369 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2370 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2373 assert(!st->codec->codec);
2374 codec = avcodec_find_decoder(st->codec->codec_id);
2376 /* Ensure that subtitle_header is properly set. */
2377 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2378 && codec && !st->codec->codec)
2379 avcodec_open2(st->codec, codec, options ? &options[i] : NULL);
2381 //try to just open decoders, in case this is enough to get parameters
2382 if(!has_codec_parameters(st->codec)){
2383 if (codec && !st->codec->codec){
2384 AVDictionary *tmp = NULL;
2386 av_dict_copy(&tmp, options[i], 0);
2387 av_dict_set(&tmp, "threads", 0, 0);
2389 avcodec_open2(st->codec, codec, options ? &tmp : NULL);
2395 for (i=0; i<ic->nb_streams; i++) {
2396 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2402 if (ff_check_interrupt(&ic->interrupt_callback)){
2404 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2408 /* check if one codec still needs to be handled */
2409 for(i=0;i<ic->nb_streams;i++) {
2410 int fps_analyze_framecount = 20;
2412 st = ic->streams[i];
2413 if (!has_codec_parameters(st->codec))
2415 /* if the timebase is coarse (like the usual millisecond precision
2416 of mkv), we need to analyze more frames to reliably arrive at
2418 if (av_q2d(st->time_base) > 0.0005)
2419 fps_analyze_framecount *= 2;
2420 if (ic->fps_probe_size >= 0)
2421 fps_analyze_framecount = ic->fps_probe_size;
2422 /* variable fps and no guess at the real fps */
2423 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2424 && st->info->duration_count < fps_analyze_framecount
2425 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2427 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2429 if(st->first_dts == AV_NOPTS_VALUE && (st->codec->codec_type == AVMEDIA_TYPE_VIDEO || st->codec->codec_type == AVMEDIA_TYPE_AUDIO))
2432 if (i == ic->nb_streams) {
2433 /* NOTE: if the format has no header, then we need to read
2434 some packets to get most of the streams, so we cannot
2436 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2437 /* if we found the info for all the codecs, we can stop */
2439 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2443 /* we did not get all the codec info, but we read too much data */
2444 if (read_size >= ic->probesize) {
2446 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2450 /* NOTE: a new stream can be added there if no header in file
2451 (AVFMTCTX_NOHEADER) */
2452 ret = read_frame_internal(ic, &pkt1);
2453 if (ret == AVERROR(EAGAIN))
2458 ret = -1; /* we could not have all the codec parameters before EOF */
2459 for(i=0;i<ic->nb_streams;i++) {
2460 st = ic->streams[i];
2461 if (!has_codec_parameters(st->codec)){
2463 avcodec_string(buf, sizeof(buf), st->codec, 0);
2464 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2472 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2473 if ((ret = av_dup_packet(pkt)) < 0)
2474 goto find_stream_info_err;
2476 read_size += pkt->size;
2478 st = ic->streams[pkt->stream_index];
2479 if (st->codec_info_nb_frames>1) {
2481 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) {
2482 av_log(ic, AV_LOG_WARNING, "max_analyze_duration %d reached at %"PRId64"\n", ic->max_analyze_duration, t);
2485 st->info->codec_info_duration += pkt->duration;
2488 int64_t last = st->info->last_dts;
2490 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
2491 double dts= pkt->dts * av_q2d(st->time_base);
2492 int64_t duration= pkt->dts - last;
2494 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2495 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2496 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); i++) {
2497 int framerate= get_std_framerate(i);
2498 double sdts= dts*framerate/(1001*12);
2500 int ticks= lrintf(sdts+j*0.5);
2501 double error= sdts - ticks + j*0.5;
2502 st->info->duration_error[j][0][i] += error;
2503 st->info->duration_error[j][1][i] += error*error;
2506 st->info->duration_count++;
2507 // ignore the first 4 values, they might have some random jitter
2508 if (st->info->duration_count > 3)
2509 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2511 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2512 st->info->last_dts = pkt->dts;
2514 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2515 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2517 st->codec->extradata_size= i;
2518 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2519 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2520 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2524 /* if still no information, we try to open the codec and to
2525 decompress the frame. We try to avoid that in most cases as
2526 it takes longer and uses more memory. For MPEG-4, we need to
2527 decompress for QuickTime.
2529 If CODEC_CAP_CHANNEL_CONF is set this will force decoding of at
2530 least one frame of codec data, this makes sure the codec initializes
2531 the channel configuration and does not only trust the values from the container.
2533 try_decode_frame(st, pkt, (options && i < orig_nb_streams )? &options[i] : NULL);
2535 st->codec_info_nb_frames++;
2539 // close codecs which were opened in try_decode_frame()
2540 for(i=0;i<ic->nb_streams;i++) {
2541 st = ic->streams[i];
2542 if(st->codec->codec)
2543 avcodec_close(st->codec);
2545 for(i=0;i<ic->nb_streams;i++) {
2546 st = ic->streams[i];
2547 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2548 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2549 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2550 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2551 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2552 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample){
2553 uint32_t tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2554 if(ff_find_pix_fmt(ff_raw_pix_fmt_tags, tag) == st->codec->pix_fmt)
2555 st->codec->codec_tag= tag;
2558 // the check for tb_unreliable() is not completely correct, since this is not about handling
2559 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2560 // ipmovie.c produces.
2561 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)
2562 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);
2563 if (st->info->duration_count && !st->r_frame_rate.num
2564 && tb_unreliable(st->codec) /*&&
2565 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2566 st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2568 double best_error= 0.01;
2570 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error[0][0]); j++) {
2573 if(st->info->codec_info_duration && st->info->codec_info_duration*av_q2d(st->time_base) < (1001*12.0)/get_std_framerate(j))
2576 int n= st->info->duration_count;
2577 double a= st->info->duration_error[k][0][j] / n;
2578 double error= st->info->duration_error[k][1][j]/n - a*a;
2580 if(error < best_error && best_error> 0.000000001){
2582 num = get_std_framerate(j);
2585 av_log(NULL, AV_LOG_DEBUG, "rfps: %f %f\n", get_std_framerate(j) / 12.0/1001, error);
2588 // do not increase frame rate by more than 1 % in order to match a standard rate.
2589 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2590 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2593 if (!st->r_frame_rate.num){
2594 if( st->codec->time_base.den * (int64_t)st->time_base.num
2595 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2596 st->r_frame_rate.num = st->codec->time_base.den;
2597 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2599 st->r_frame_rate.num = st->time_base.den;
2600 st->r_frame_rate.den = st->time_base.num;
2603 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2604 if(!st->codec->bits_per_coded_sample)
2605 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2606 // set stream disposition based on audio service type
2607 switch (st->codec->audio_service_type) {
2608 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2609 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2610 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2611 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2612 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2613 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2614 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2615 st->disposition = AV_DISPOSITION_COMMENT; break;
2616 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2617 st->disposition = AV_DISPOSITION_KARAOKE; break;
2622 estimate_timings(ic, old_offset);
2624 compute_chapters_end(ic);
2627 /* correct DTS for B-frame streams with no timestamps */
2628 for(i=0;i<ic->nb_streams;i++) {
2629 st = ic->streams[i];
2630 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2632 ppktl = &ic->packet_buffer;
2634 if(ppkt1->stream_index != i)
2636 if(ppkt1->pkt->dts < 0)
2638 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2640 ppkt1->pkt->dts -= delta;
2645 st->cur_dts -= delta;
2651 find_stream_info_err:
2652 for (i=0; i < ic->nb_streams; i++)
2653 av_freep(&ic->streams[i]->info);
2657 AVProgram *av_find_program_from_stream(AVFormatContext *ic, AVProgram *last, int s)
2661 for (i = 0; i < ic->nb_programs; i++) {
2662 if (ic->programs[i] == last) {
2666 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2667 if (ic->programs[i]->stream_index[j] == s)
2668 return ic->programs[i];
2674 int av_find_best_stream(AVFormatContext *ic,
2675 enum AVMediaType type,
2676 int wanted_stream_nb,
2678 AVCodec **decoder_ret,
2681 int i, nb_streams = ic->nb_streams;
2682 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2683 unsigned *program = NULL;
2684 AVCodec *decoder = NULL, *best_decoder = NULL;
2686 if (related_stream >= 0 && wanted_stream_nb < 0) {
2687 AVProgram *p = av_find_program_from_stream(ic, NULL, related_stream);
2689 program = p->stream_index;
2690 nb_streams = p->nb_stream_indexes;
2693 for (i = 0; i < nb_streams; i++) {
2694 int real_stream_index = program ? program[i] : i;
2695 AVStream *st = ic->streams[real_stream_index];
2696 AVCodecContext *avctx = st->codec;
2697 if (avctx->codec_type != type)
2699 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2701 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2704 decoder = avcodec_find_decoder(st->codec->codec_id);
2707 ret = AVERROR_DECODER_NOT_FOUND;
2711 if (best_count >= st->codec_info_nb_frames)
2713 best_count = st->codec_info_nb_frames;
2714 ret = real_stream_index;
2715 best_decoder = decoder;
2716 if (program && i == nb_streams - 1 && ret < 0) {
2718 nb_streams = ic->nb_streams;
2719 i = 0; /* no related stream found, try again with everything */
2723 *decoder_ret = best_decoder;
2727 /*******************************************************/
2729 int av_read_play(AVFormatContext *s)
2731 if (s->iformat->read_play)
2732 return s->iformat->read_play(s);
2734 return avio_pause(s->pb, 0);
2735 return AVERROR(ENOSYS);
2738 int av_read_pause(AVFormatContext *s)
2740 if (s->iformat->read_pause)
2741 return s->iformat->read_pause(s);
2743 return avio_pause(s->pb, 1);
2744 return AVERROR(ENOSYS);
2747 void av_close_input_stream(AVFormatContext *s)
2749 flush_packet_queue(s);
2750 if (s->iformat->read_close)
2751 s->iformat->read_close(s);
2752 avformat_free_context(s);
2755 void avformat_free_context(AVFormatContext *s)
2761 if (s->iformat && s->iformat->priv_class && s->priv_data)
2762 av_opt_free(s->priv_data);
2764 for(i=0;i<s->nb_streams;i++) {
2765 /* free all data in a stream component */
2768 av_parser_close(st->parser);
2769 av_free_packet(&st->cur_pkt);
2771 av_dict_free(&st->metadata);
2772 av_freep(&st->index_entries);
2773 av_freep(&st->codec->extradata);
2774 av_freep(&st->codec->subtitle_header);
2775 av_freep(&st->codec);
2776 av_freep(&st->priv_data);
2777 av_freep(&st->info);
2780 for(i=s->nb_programs-1; i>=0; i--) {
2781 av_dict_free(&s->programs[i]->metadata);
2782 av_freep(&s->programs[i]->stream_index);
2783 av_freep(&s->programs[i]);
2785 av_freep(&s->programs);
2786 av_freep(&s->priv_data);
2787 while(s->nb_chapters--) {
2788 av_dict_free(&s->chapters[s->nb_chapters]->metadata);
2789 av_freep(&s->chapters[s->nb_chapters]);
2791 av_freep(&s->chapters);
2792 av_dict_free(&s->metadata);
2793 av_freep(&s->streams);
2797 void av_close_input_file(AVFormatContext *s)
2799 AVIOContext *pb = (s->iformat->flags & AVFMT_NOFILE) || (s->flags & AVFMT_FLAG_CUSTOM_IO) ?
2801 av_close_input_stream(s);
2806 #if FF_API_NEW_STREAM
2807 AVStream *av_new_stream(AVFormatContext *s, int id)
2809 AVStream *st = avformat_new_stream(s, NULL);
2816 AVStream *avformat_new_stream(AVFormatContext *s, AVCodec *c)
2822 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2824 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2827 s->streams = streams;
2829 st = av_mallocz(sizeof(AVStream));
2832 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2837 st->codec = avcodec_alloc_context3(c);
2839 /* no default bitrate if decoding */
2840 st->codec->bit_rate = 0;
2842 st->index = s->nb_streams;
2843 st->start_time = AV_NOPTS_VALUE;
2844 st->duration = AV_NOPTS_VALUE;
2845 /* we set the current DTS to 0 so that formats without any timestamps
2846 but durations get some timestamps, formats with some unknown
2847 timestamps have their first few packets buffered and the
2848 timestamps corrected before they are returned to the user */
2850 st->first_dts = AV_NOPTS_VALUE;
2851 st->probe_packets = MAX_PROBE_PACKETS;
2853 /* default pts setting is MPEG-like */
2854 av_set_pts_info(st, 33, 1, 90000);
2855 st->last_IP_pts = AV_NOPTS_VALUE;
2856 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2857 st->pts_buffer[i]= AV_NOPTS_VALUE;
2858 st->reference_dts = AV_NOPTS_VALUE;
2860 st->sample_aspect_ratio = (AVRational){0,1};
2862 s->streams[s->nb_streams++] = st;
2866 AVProgram *av_new_program(AVFormatContext *ac, int id)
2868 AVProgram *program=NULL;
2871 av_dlog(ac, "new_program: id=0x%04x\n", id);
2873 for(i=0; i<ac->nb_programs; i++)
2874 if(ac->programs[i]->id == id)
2875 program = ac->programs[i];
2878 program = av_mallocz(sizeof(AVProgram));
2881 dynarray_add(&ac->programs, &ac->nb_programs, program);
2882 program->discard = AVDISCARD_NONE;
2889 AVChapter *avpriv_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2891 AVChapter *chapter = NULL;
2894 for(i=0; i<s->nb_chapters; i++)
2895 if(s->chapters[i]->id == id)
2896 chapter = s->chapters[i];
2899 chapter= av_mallocz(sizeof(AVChapter));
2902 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2904 av_dict_set(&chapter->metadata, "title", title, 0);
2906 chapter->time_base= time_base;
2907 chapter->start = start;
2913 /************************************************************/
2914 /* output media file */
2916 #if FF_API_FORMAT_PARAMETERS
2917 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2919 if (s->oformat->priv_data_size > 0) {
2920 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2922 return AVERROR(ENOMEM);
2923 if (s->oformat->priv_class) {
2924 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2925 av_opt_set_defaults(s->priv_data);
2928 s->priv_data = NULL;
2934 int avformat_alloc_output_context2(AVFormatContext **avctx, AVOutputFormat *oformat,
2935 const char *format, const char *filename)
2937 AVFormatContext *s = avformat_alloc_context();
2946 oformat = av_guess_format(format, NULL, NULL);
2948 av_log(s, AV_LOG_ERROR, "Requested output format '%s' is not a suitable output format\n", format);
2949 ret = AVERROR(EINVAL);
2953 oformat = av_guess_format(NULL, filename, NULL);
2955 ret = AVERROR(EINVAL);
2956 av_log(s, AV_LOG_ERROR, "Unable to find a suitable output format for '%s'\n",
2963 s->oformat = oformat;
2964 if (s->oformat->priv_data_size > 0) {
2965 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2968 if (s->oformat->priv_class) {
2969 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2970 av_opt_set_defaults(s->priv_data);
2973 s->priv_data = NULL;
2976 av_strlcpy(s->filename, filename, sizeof(s->filename));
2980 av_log(s, AV_LOG_ERROR, "Out of memory\n");
2981 ret = AVERROR(ENOMEM);
2983 avformat_free_context(s);
2987 #if FF_API_ALLOC_OUTPUT_CONTEXT
2988 AVFormatContext *avformat_alloc_output_context(const char *format,
2989 AVOutputFormat *oformat, const char *filename)
2991 AVFormatContext *avctx;
2992 int ret = avformat_alloc_output_context2(&avctx, oformat, format, filename);
2993 return ret < 0 ? NULL : avctx;
2997 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2999 const AVCodecTag *avctag;
3001 enum CodecID id = CODEC_ID_NONE;
3002 unsigned int tag = 0;
3005 * Check that tag + id is in the table
3006 * If neither is in the table -> OK
3007 * If tag is in the table with another id -> FAIL
3008 * If id is in the table with another tag -> FAIL unless strict < normal
3010 for (n = 0; s->oformat->codec_tag[n]; n++) {
3011 avctag = s->oformat->codec_tag[n];
3012 while (avctag->id != CODEC_ID_NONE) {
3013 if (avpriv_toupper4(avctag->tag) == avpriv_toupper4(st->codec->codec_tag)) {
3015 if (id == st->codec->codec_id)
3018 if (avctag->id == st->codec->codec_id)
3023 if (id != CODEC_ID_NONE)
3025 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
3030 #if FF_API_FORMAT_PARAMETERS
3031 int av_write_header(AVFormatContext *s)
3033 return avformat_write_header(s, NULL);
3037 int avformat_write_header(AVFormatContext *s, AVDictionary **options)
3041 AVDictionary *tmp = NULL;
3044 av_dict_copy(&tmp, *options, 0);
3045 if ((ret = av_opt_set_dict(s, &tmp)) < 0)
3047 if (s->priv_data && s->oformat->priv_class && *(const AVClass**)s->priv_data==s->oformat->priv_class &&
3048 (ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3051 // some sanity checks
3052 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
3053 av_log(s, AV_LOG_ERROR, "no streams\n");
3054 ret = AVERROR(EINVAL);
3058 for(i=0;i<s->nb_streams;i++) {
3061 switch (st->codec->codec_type) {
3062 case AVMEDIA_TYPE_AUDIO:
3063 if(st->codec->sample_rate<=0){
3064 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
3065 ret = AVERROR(EINVAL);
3068 if(!st->codec->block_align)
3069 st->codec->block_align = st->codec->channels *
3070 av_get_bits_per_sample(st->codec->codec_id) >> 3;
3072 case AVMEDIA_TYPE_VIDEO:
3073 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
3074 av_log(s, AV_LOG_ERROR, "time base not set\n");
3075 ret = AVERROR(EINVAL);
3078 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
3079 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
3080 ret = AVERROR(EINVAL);
3083 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)
3084 && FFABS(av_q2d(st->sample_aspect_ratio) - av_q2d(st->codec->sample_aspect_ratio)) > 0.004*av_q2d(st->sample_aspect_ratio)
3086 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
3087 ret = AVERROR(EINVAL);
3093 if(s->oformat->codec_tag){
3094 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)){
3095 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
3096 st->codec->codec_tag= 0;
3098 if(st->codec->codec_tag){
3099 if (!validate_codec_tag(s, st)) {
3101 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
3102 av_log(s, AV_LOG_ERROR,
3103 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
3104 tagbuf, st->codec->codec_tag, st->codec->codec_id);
3105 ret = AVERROR_INVALIDDATA;
3109 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
3112 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
3113 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
3114 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
3117 if (!s->priv_data && s->oformat->priv_data_size > 0) {
3118 s->priv_data = av_mallocz(s->oformat->priv_data_size);
3119 if (!s->priv_data) {
3120 ret = AVERROR(ENOMEM);
3123 if (s->oformat->priv_class) {
3124 *(const AVClass**)s->priv_data= s->oformat->priv_class;
3125 av_opt_set_defaults(s->priv_data);
3126 if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
3131 /* set muxer identification string */
3132 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
3133 av_dict_set(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
3136 if(s->oformat->write_header){
3137 ret = s->oformat->write_header(s);
3142 /* init PTS generation */
3143 for(i=0;i<s->nb_streams;i++) {
3144 int64_t den = AV_NOPTS_VALUE;
3147 switch (st->codec->codec_type) {
3148 case AVMEDIA_TYPE_AUDIO:
3149 den = (int64_t)st->time_base.num * st->codec->sample_rate;
3151 case AVMEDIA_TYPE_VIDEO:
3152 den = (int64_t)st->time_base.num * st->codec->time_base.den;
3157 if (den != AV_NOPTS_VALUE) {
3159 ret = AVERROR_INVALIDDATA;
3162 frac_init(&st->pts, 0, 0, den);
3167 av_dict_free(options);
3176 //FIXME merge with compute_pkt_fields
3177 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
3178 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
3179 int num, den, frame_size, i;
3181 av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
3182 pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
3184 /* duration field */
3185 if (pkt->duration == 0) {
3186 compute_frame_duration(&num, &den, st, NULL, pkt);
3188 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
3192 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
3195 //XXX/FIXME this is a temporary hack until all encoders output pts
3196 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
3198 // pkt->pts= st->cur_dts;
3199 pkt->pts= st->pts.val;
3202 //calculate dts from pts
3203 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
3204 st->pts_buffer[0]= pkt->pts;
3205 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
3206 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
3207 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
3208 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
3210 pkt->dts= st->pts_buffer[0];
3213 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)){
3214 av_log(s, AV_LOG_ERROR,
3215 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
3216 st->index, st->cur_dts, pkt->dts);
3217 return AVERROR(EINVAL);
3219 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
3220 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
3221 return AVERROR(EINVAL);
3224 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
3225 st->cur_dts= pkt->dts;
3226 st->pts.val= pkt->dts;
3229 switch (st->codec->codec_type) {
3230 case AVMEDIA_TYPE_AUDIO:
3231 frame_size = get_audio_frame_size(st->codec, pkt->size);
3233 /* HACK/FIXME, we skip the initial 0 size packets as they are most
3234 likely equal to the encoder delay, but it would be better if we
3235 had the real timestamps from the encoder */
3236 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
3237 frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
3240 case AVMEDIA_TYPE_VIDEO:
3241 frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3249 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3251 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3253 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3256 ret= s->oformat->write_packet(s, pkt);
3259 s->streams[pkt->stream_index]->nb_frames++;
3263 int ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3264 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3266 AVPacketList **next_point, *this_pktl;
3268 this_pktl = av_mallocz(sizeof(AVPacketList));
3270 return AVERROR(ENOMEM);
3271 this_pktl->pkt= *pkt;
3272 pkt->destruct= NULL; // do not free original but only the copy
3273 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
3275 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3276 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3278 next_point = &s->packet_buffer;
3281 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3282 while(!compare(s, &(*next_point)->pkt, pkt)){
3283 next_point= &(*next_point)->next;
3287 next_point = &(s->packet_buffer_end->next);
3290 assert(!*next_point);
3292 s->packet_buffer_end= this_pktl;
3295 this_pktl->next= *next_point;
3297 s->streams[pkt->stream_index]->last_in_packet_buffer=
3298 *next_point= this_pktl;
3302 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3304 AVStream *st = s->streams[ pkt ->stream_index];
3305 AVStream *st2= s->streams[ next->stream_index];
3306 int comp = av_compare_ts(next->dts, st2->time_base, pkt->dts,
3310 return pkt->stream_index < next->stream_index;
3314 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3316 int stream_count=0, noninterleaved_count=0;
3317 int64_t delta_dts_max = 0;
3321 ret = ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3326 for(i=0; i < s->nb_streams; i++) {
3327 if (s->streams[i]->last_in_packet_buffer) {
3329 } else if(s->streams[i]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3330 ++noninterleaved_count;
3334 if (s->nb_streams == stream_count) {
3337 for(i=0; i < s->nb_streams; i++) {
3338 if (s->streams[i]->last_in_packet_buffer) {
3340 av_rescale_q(s->streams[i]->last_in_packet_buffer->pkt.dts,
3341 s->streams[i]->time_base,
3343 av_rescale_q(s->packet_buffer->pkt.dts,
3344 s->streams[s->packet_buffer->pkt.stream_index]->time_base,
3346 delta_dts_max= FFMAX(delta_dts_max, delta_dts);
3349 if(s->nb_streams == stream_count+noninterleaved_count &&
3350 delta_dts_max > 20*AV_TIME_BASE) {
3351 av_log(s, AV_LOG_DEBUG, "flushing with %d noninterleaved\n", noninterleaved_count);
3355 if(stream_count && flush){
3356 pktl= s->packet_buffer;
3359 s->packet_buffer= pktl->next;
3360 if(!s->packet_buffer)
3361 s->packet_buffer_end= NULL;
3363 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3364 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3368 av_init_packet(out);
3374 * Interleave an AVPacket correctly so it can be muxed.
3375 * @param out the interleaved packet will be output here
3376 * @param in the input packet
3377 * @param flush 1 if no further packets are available as input and all
3378 * remaining packets should be output
3379 * @return 1 if a packet was output, 0 if no packet could be output,
3380 * < 0 if an error occurred
3382 static int interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3383 if(s->oformat->interleave_packet)
3384 return s->oformat->interleave_packet(s, out, in, flush);
3386 return av_interleave_packet_per_dts(s, out, in, flush);
3389 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3390 AVStream *st= s->streams[ pkt->stream_index];
3393 //FIXME/XXX/HACK drop zero sized packets
3394 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3397 av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3398 pkt->size, pkt->dts, pkt->pts);
3399 if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3402 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3403 return AVERROR(EINVAL);
3407 int ret= interleave_packet(s, &opkt, pkt, 0);
3408 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3411 ret= s->oformat->write_packet(s, &opkt);
3413 s->streams[opkt.stream_index]->nb_frames++;
3415 av_free_packet(&opkt);
3420 if(s->pb && s->pb->error)
3421 return s->pb->error;
3425 int av_write_trailer(AVFormatContext *s)
3431 ret= interleave_packet(s, &pkt, NULL, 1);
3432 if(ret<0) //FIXME cleanup needed for ret<0 ?
3437 ret= s->oformat->write_packet(s, &pkt);
3439 s->streams[pkt.stream_index]->nb_frames++;
3441 av_free_packet(&pkt);
3445 if(s->pb && s->pb->error)
3449 if(s->oformat->write_trailer)
3450 ret = s->oformat->write_trailer(s);
3453 ret = s->pb ? s->pb->error : 0;
3454 for(i=0;i<s->nb_streams;i++) {
3455 av_freep(&s->streams[i]->priv_data);
3456 av_freep(&s->streams[i]->index_entries);
3458 if (s->iformat && s->iformat->priv_class)
3459 av_opt_free(s->priv_data);
3460 av_freep(&s->priv_data);
3464 int av_get_output_timestamp(struct AVFormatContext *s, int stream,
3465 int64_t *dts, int64_t *wall)
3467 if (!s->oformat || !s->oformat->get_output_timestamp)
3468 return AVERROR(ENOSYS);
3469 s->oformat->get_output_timestamp(s, stream, dts, wall);
3473 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3476 AVProgram *program=NULL;
3479 if (idx >= ac->nb_streams) {
3480 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3484 for(i=0; i<ac->nb_programs; i++){
3485 if(ac->programs[i]->id != progid)
3487 program = ac->programs[i];
3488 for(j=0; j<program->nb_stream_indexes; j++)
3489 if(program->stream_index[j] == idx)
3492 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3495 program->stream_index = tmp;
3496 program->stream_index[program->nb_stream_indexes++] = idx;
3501 static void print_fps(double d, const char *postfix){
3502 uint64_t v= lrintf(d*100);
3503 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3504 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3505 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3508 static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
3510 if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
3511 AVDictionaryEntry *tag=NULL;
3513 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3514 while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
3515 if(strcmp("language", tag->key)){
3518 av_strlcpy(tmp, tag->value, sizeof(tmp));
3519 for(i=0; i<strlen(tmp); i++) if(tmp[i]==0xd) tmp[i]=' ';
3520 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tmp);
3526 /* "user interface" functions */
3527 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3530 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3531 AVStream *st = ic->streams[i];
3532 int g = av_gcd(st->time_base.num, st->time_base.den);
3533 AVDictionaryEntry *lang = av_dict_get(st->metadata, "language", NULL, 0);
3534 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3535 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d", index, i);
3536 /* the pid is an important information, so we display it */
3537 /* XXX: add a generic system */
3538 if (flags & AVFMT_SHOW_IDS)
3539 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3541 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3542 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3543 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3544 if (st->sample_aspect_ratio.num && // default
3545 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3546 AVRational display_aspect_ratio;
3547 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3548 st->codec->width*st->sample_aspect_ratio.num,
3549 st->codec->height*st->sample_aspect_ratio.den,
3551 av_log(NULL, AV_LOG_INFO, ", SAR %d:%d DAR %d:%d",
3552 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3553 display_aspect_ratio.num, display_aspect_ratio.den);
3555 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3556 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3557 print_fps(av_q2d(st->avg_frame_rate), "fps");
3558 if(st->r_frame_rate.den && st->r_frame_rate.num)
3559 print_fps(av_q2d(st->r_frame_rate), "tbr");
3560 if(st->time_base.den && st->time_base.num)
3561 print_fps(1/av_q2d(st->time_base), "tbn");
3562 if(st->codec->time_base.den && st->codec->time_base.num)
3563 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3565 if (st->disposition & AV_DISPOSITION_DEFAULT)
3566 av_log(NULL, AV_LOG_INFO, " (default)");
3567 if (st->disposition & AV_DISPOSITION_DUB)
3568 av_log(NULL, AV_LOG_INFO, " (dub)");
3569 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3570 av_log(NULL, AV_LOG_INFO, " (original)");
3571 if (st->disposition & AV_DISPOSITION_COMMENT)
3572 av_log(NULL, AV_LOG_INFO, " (comment)");
3573 if (st->disposition & AV_DISPOSITION_LYRICS)
3574 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3575 if (st->disposition & AV_DISPOSITION_KARAOKE)
3576 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3577 if (st->disposition & AV_DISPOSITION_FORCED)
3578 av_log(NULL, AV_LOG_INFO, " (forced)");
3579 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3580 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3581 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3582 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3583 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3584 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3585 av_log(NULL, AV_LOG_INFO, "\n");
3586 dump_metadata(NULL, st->metadata, " ");
3589 #if FF_API_DUMP_FORMAT
3590 void dump_format(AVFormatContext *ic,
3595 av_dump_format(ic, index, url, is_output);
3599 void av_dump_format(AVFormatContext *ic,
3605 uint8_t *printed = ic->nb_streams ? av_mallocz(ic->nb_streams) : NULL;
3606 if (ic->nb_streams && !printed)
3609 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3610 is_output ? "Output" : "Input",
3612 is_output ? ic->oformat->name : ic->iformat->name,
3613 is_output ? "to" : "from", url);
3614 dump_metadata(NULL, ic->metadata, " ");
3616 av_log(NULL, AV_LOG_INFO, " Duration: ");
3617 if (ic->duration != AV_NOPTS_VALUE) {
3618 int hours, mins, secs, us;
3619 secs = ic->duration / AV_TIME_BASE;
3620 us = ic->duration % AV_TIME_BASE;
3625 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3626 (100 * us) / AV_TIME_BASE);
3628 av_log(NULL, AV_LOG_INFO, "N/A");
3630 if (ic->start_time != AV_NOPTS_VALUE) {
3632 av_log(NULL, AV_LOG_INFO, ", start: ");
3633 secs = ic->start_time / AV_TIME_BASE;
3634 us = abs(ic->start_time % AV_TIME_BASE);
3635 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3636 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3638 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3640 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3642 av_log(NULL, AV_LOG_INFO, "N/A");
3644 av_log(NULL, AV_LOG_INFO, "\n");
3646 for (i = 0; i < ic->nb_chapters; i++) {
3647 AVChapter *ch = ic->chapters[i];
3648 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3649 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3650 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3652 dump_metadata(NULL, ch->metadata, " ");
3654 if(ic->nb_programs) {
3655 int j, k, total = 0;
3656 for(j=0; j<ic->nb_programs; j++) {
3657 AVDictionaryEntry *name = av_dict_get(ic->programs[j]->metadata,
3659 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3660 name ? name->value : "");
3661 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3662 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3663 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3664 printed[ic->programs[j]->stream_index[k]] = 1;
3666 total += ic->programs[j]->nb_stream_indexes;
3668 if (total < ic->nb_streams)
3669 av_log(NULL, AV_LOG_INFO, " No Program\n");
3671 for(i=0;i<ic->nb_streams;i++)
3673 dump_stream_format(ic, i, index, is_output);
3678 int64_t av_gettime(void)
3681 gettimeofday(&tv,NULL);
3682 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3685 uint64_t ff_ntp_time(void)
3687 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3690 #if FF_API_PARSE_DATE
3691 #include "libavutil/parseutils.h"
3693 int64_t parse_date(const char *timestr, int duration)
3696 av_parse_time(&timeval, timestr, duration);
3701 #if FF_API_FIND_INFO_TAG
3702 #include "libavutil/parseutils.h"
3704 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3706 return av_find_info_tag(arg, arg_size, tag1, info);
3710 int av_get_frame_filename(char *buf, int buf_size,
3711 const char *path, int number)
3714 char *q, buf1[20], c;
3715 int nd, len, percentd_found;
3727 while (isdigit(*p)) {
3728 nd = nd * 10 + *p++ - '0';
3731 } while (isdigit(c));
3740 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3742 if ((q - buf + len) > buf_size - 1)
3744 memcpy(q, buf1, len);
3752 if ((q - buf) < buf_size - 1)
3756 if (!percentd_found)
3765 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3769 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3771 for(i=0;i<size;i+=16) {
3778 PRINT(" %02x", buf[i+j]);
3783 for(j=0;j<len;j++) {
3785 if (c < ' ' || c > '~')
3794 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3796 hex_dump_internal(NULL, f, 0, buf, size);
3799 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3801 hex_dump_internal(avcl, NULL, level, buf, size);
3804 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3807 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3808 PRINT("stream #%d:\n", pkt->stream_index);
3809 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3810 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3811 /* DTS is _always_ valid after av_read_frame() */
3813 if (pkt->dts == AV_NOPTS_VALUE)
3816 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3817 /* PTS may not be known if B-frames are present. */
3819 if (pkt->pts == AV_NOPTS_VALUE)
3822 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3824 PRINT(" size=%d\n", pkt->size);
3827 av_hex_dump(f, pkt->data, pkt->size);
3831 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3833 AVRational tb = { 1, AV_TIME_BASE };
3834 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3838 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3840 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3844 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3846 AVRational tb = { 1, AV_TIME_BASE };
3847 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3851 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3854 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3857 void av_url_split(char *proto, int proto_size,
3858 char *authorization, int authorization_size,
3859 char *hostname, int hostname_size,
3861 char *path, int path_size,
3864 const char *p, *ls, *at, *col, *brk;
3866 if (port_ptr) *port_ptr = -1;
3867 if (proto_size > 0) proto[0] = 0;
3868 if (authorization_size > 0) authorization[0] = 0;
3869 if (hostname_size > 0) hostname[0] = 0;
3870 if (path_size > 0) path[0] = 0;
3872 /* parse protocol */
3873 if ((p = strchr(url, ':'))) {
3874 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3879 /* no protocol means plain filename */
3880 av_strlcpy(path, url, path_size);
3884 /* separate path from hostname */
3885 ls = strchr(p, '/');
3887 ls = strchr(p, '?');
3889 av_strlcpy(path, ls, path_size);
3891 ls = &p[strlen(p)]; // XXX
3893 /* the rest is hostname, use that to parse auth/port */
3895 /* authorization (user[:pass]@hostname) */
3896 if ((at = strchr(p, '@')) && at < ls) {
3897 av_strlcpy(authorization, p,
3898 FFMIN(authorization_size, at + 1 - p));
3899 p = at + 1; /* skip '@' */
3902 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3904 av_strlcpy(hostname, p + 1,
3905 FFMIN(hostname_size, brk - p));
3906 if (brk[1] == ':' && port_ptr)
3907 *port_ptr = atoi(brk + 2);
3908 } else if ((col = strchr(p, ':')) && col < ls) {
3909 av_strlcpy(hostname, p,
3910 FFMIN(col + 1 - p, hostname_size));
3911 if (port_ptr) *port_ptr = atoi(col + 1);
3913 av_strlcpy(hostname, p,
3914 FFMIN(ls + 1 - p, hostname_size));
3918 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3921 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3924 'C', 'D', 'E', 'F' };
3925 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3928 'c', 'd', 'e', 'f' };
3929 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3931 for(i = 0; i < s; i++) {
3932 buff[i * 2] = hex_table[src[i] >> 4];
3933 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3939 int ff_hex_to_data(uint8_t *data, const char *p)
3946 p += strspn(p, SPACE_CHARS);
3949 c = toupper((unsigned char) *p++);
3950 if (c >= '0' && c <= '9')
3952 else if (c >= 'A' && c <= 'F')
3967 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3968 unsigned int pts_num, unsigned int pts_den)
3971 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3972 if(new_tb.num != pts_num)
3973 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3975 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3977 if(new_tb.num <= 0 || new_tb.den <= 0) {
3978 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3981 s->time_base = new_tb;
3982 s->pts_wrap_bits = pts_wrap_bits;
3985 int ff_url_join(char *str, int size, const char *proto,
3986 const char *authorization, const char *hostname,
3987 int port, const char *fmt, ...)
3990 struct addrinfo hints, *ai;
3995 av_strlcatf(str, size, "%s://", proto);
3996 if (authorization && authorization[0])
3997 av_strlcatf(str, size, "%s@", authorization);
3998 #if CONFIG_NETWORK && defined(AF_INET6)
3999 /* Determine if hostname is a numerical IPv6 address,
4000 * properly escape it within [] in that case. */
4001 memset(&hints, 0, sizeof(hints));
4002 hints.ai_flags = AI_NUMERICHOST;
4003 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
4004 if (ai->ai_family == AF_INET6) {
4005 av_strlcat(str, "[", size);
4006 av_strlcat(str, hostname, size);
4007 av_strlcat(str, "]", size);
4009 av_strlcat(str, hostname, size);
4014 /* Not an IPv6 address, just output the plain string. */
4015 av_strlcat(str, hostname, size);
4018 av_strlcatf(str, size, ":%d", port);
4021 int len = strlen(str);
4024 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
4030 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
4031 AVFormatContext *src)
4036 local_pkt.stream_index = dst_stream;
4037 if (pkt->pts != AV_NOPTS_VALUE)
4038 local_pkt.pts = av_rescale_q(pkt->pts,
4039 src->streams[pkt->stream_index]->time_base,
4040 dst->streams[dst_stream]->time_base);
4041 if (pkt->dts != AV_NOPTS_VALUE)
4042 local_pkt.dts = av_rescale_q(pkt->dts,
4043 src->streams[pkt->stream_index]->time_base,
4044 dst->streams[dst_stream]->time_base);
4045 return av_write_frame(dst, &local_pkt);
4048 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
4051 const char *ptr = str;
4053 /* Parse key=value pairs. */
4056 char *dest = NULL, *dest_end;
4057 int key_len, dest_len = 0;
4059 /* Skip whitespace and potential commas. */
4060 while (*ptr && (isspace(*ptr) || *ptr == ','))
4067 if (!(ptr = strchr(key, '=')))
4070 key_len = ptr - key;
4072 callback_get_buf(context, key, key_len, &dest, &dest_len);
4073 dest_end = dest + dest_len - 1;
4077 while (*ptr && *ptr != '\"') {
4081 if (dest && dest < dest_end)
4085 if (dest && dest < dest_end)
4093 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
4094 if (dest && dest < dest_end)
4102 int ff_find_stream_index(AVFormatContext *s, int id)
4105 for (i = 0; i < s->nb_streams; i++) {
4106 if (s->streams[i]->id == id)
4112 void ff_make_absolute_url(char *buf, int size, const char *base,
4116 /* Absolute path, relative to the current server */
4117 if (base && strstr(base, "://") && rel[0] == '/') {
4119 av_strlcpy(buf, base, size);
4120 sep = strstr(buf, "://");
4123 sep = strchr(sep, '/');
4127 av_strlcat(buf, rel, size);
4130 /* If rel actually is an absolute url, just copy it */
4131 if (!base || strstr(rel, "://") || rel[0] == '/') {
4132 av_strlcpy(buf, rel, size);
4136 av_strlcpy(buf, base, size);
4137 /* Remove the file name from the base url */
4138 sep = strrchr(buf, '/');
4143 while (av_strstart(rel, "../", NULL) && sep) {
4144 /* Remove the path delimiter at the end */
4146 sep = strrchr(buf, '/');
4147 /* If the next directory name to pop off is "..", break here */
4148 if (!strcmp(sep ? &sep[1] : buf, "..")) {
4149 /* Readd the slash we just removed */
4150 av_strlcat(buf, "/", size);
4153 /* Cut off the directory name */
4160 av_strlcat(buf, rel, size);
4163 int64_t ff_iso8601_to_unix_time(const char *datestr)
4166 struct tm time1 = {0}, time2 = {0};
4168 ret1 = strptime(datestr, "%Y - %m - %d %T", &time1);
4169 ret2 = strptime(datestr, "%Y - %m - %dT%T", &time2);
4171 return av_timegm(&time2);
4173 return av_timegm(&time1);
4175 av_log(NULL, AV_LOG_WARNING, "strptime() unavailable on this system, cannot convert "
4176 "the date string.\n");
4181 int avformat_query_codec(AVOutputFormat *ofmt, enum CodecID codec_id, int std_compliance)
4184 if (ofmt->query_codec)
4185 return ofmt->query_codec(codec_id, std_compliance);
4186 else if (ofmt->codec_tag)
4187 return !!av_codec_get_tag(ofmt->codec_tag, codec_id);
4188 else if (codec_id == ofmt->video_codec || codec_id == ofmt->audio_codec ||
4189 codec_id == ofmt->subtitle_codec)
4192 return AVERROR_PATCHWELCOME;
4195 int avformat_network_init(void)
4199 ff_network_inited_globally = 1;
4200 if ((ret = ff_network_init()) < 0)
4207 int avformat_network_deinit(void)