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 "libavutil/opt.h"
31 #include "libavutil/avstring.h"
33 #include "audiointerleave.h"
47 * various utility functions for use within FFmpeg
50 unsigned avformat_version(void)
52 return LIBAVFORMAT_VERSION_INT;
55 const char *avformat_configuration(void)
57 return FFMPEG_CONFIGURATION;
60 const char *avformat_license(void)
62 #define LICENSE_PREFIX "libavformat license: "
63 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
66 /* fraction handling */
69 * f = val + (num / den) + 0.5.
71 * 'num' is normalized so that it is such as 0 <= num < den.
73 * @param f fractional number
74 * @param val integer value
75 * @param num must be >= 0
76 * @param den must be >= 1
78 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
91 * Fractional addition to f: f = f + (incr / f->den).
93 * @param f fractional number
94 * @param incr increment, can be positive or negative
96 static void av_frac_add(AVFrac *f, int64_t incr)
109 } else if (num >= den) {
116 /** head of registered input format linked list */
117 #if !FF_API_FIRST_FORMAT
120 AVInputFormat *first_iformat = NULL;
121 /** head of registered output format linked list */
122 #if !FF_API_FIRST_FORMAT
125 AVOutputFormat *first_oformat = NULL;
127 AVInputFormat *av_iformat_next(AVInputFormat *f)
129 if(f) return f->next;
130 else return first_iformat;
133 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
135 if(f) return f->next;
136 else return first_oformat;
139 void av_register_input_format(AVInputFormat *format)
143 while (*p != NULL) p = &(*p)->next;
148 void av_register_output_format(AVOutputFormat *format)
152 while (*p != NULL) p = &(*p)->next;
157 int av_match_ext(const char *filename, const char *extensions)
165 ext = strrchr(filename, '.');
171 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
174 if (!strcasecmp(ext1, ext))
184 static int match_format(const char *name, const char *names)
192 namelen = strlen(name);
193 while ((p = strchr(names, ','))) {
194 len = FFMAX(p - names, namelen);
195 if (!strncasecmp(name, names, len))
199 return !strcasecmp(name, names);
202 #if FF_API_GUESS_FORMAT
203 AVOutputFormat *guess_format(const char *short_name, const char *filename,
204 const char *mime_type)
206 return av_guess_format(short_name, filename, mime_type);
210 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
211 const char *mime_type)
213 AVOutputFormat *fmt = NULL, *fmt_found;
214 int score_max, score;
216 /* specific test for image sequences */
217 #if CONFIG_IMAGE2_MUXER
218 if (!short_name && filename &&
219 av_filename_number_test(filename) &&
220 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
221 return av_guess_format("image2", NULL, NULL);
224 /* Find the proper file type. */
227 while ((fmt = av_oformat_next(fmt))) {
229 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
231 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
233 if (filename && fmt->extensions &&
234 av_match_ext(filename, fmt->extensions)) {
237 if (score > score_max) {
245 #if FF_API_GUESS_FORMAT
246 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
247 const char *mime_type)
249 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
252 AVOutputFormat *stream_fmt;
253 char stream_format_name[64];
255 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
256 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
266 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
267 const char *filename, const char *mime_type, enum AVMediaType type){
268 if(type == AVMEDIA_TYPE_VIDEO){
269 enum CodecID codec_id= CODEC_ID_NONE;
271 #if CONFIG_IMAGE2_MUXER
272 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
273 codec_id= av_guess_image2_codec(filename);
276 if(codec_id == CODEC_ID_NONE)
277 codec_id= fmt->video_codec;
279 }else if(type == AVMEDIA_TYPE_AUDIO)
280 return fmt->audio_codec;
281 else if (type == AVMEDIA_TYPE_SUBTITLE)
282 return fmt->subtitle_codec;
284 return CODEC_ID_NONE;
287 AVInputFormat *av_find_input_format(const char *short_name)
289 AVInputFormat *fmt = NULL;
290 while ((fmt = av_iformat_next(fmt))) {
291 if (match_format(short_name, fmt->name))
297 #if FF_API_SYMVER && CONFIG_SHARED && HAVE_SYMVER
298 FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
300 av_destruct_packet_nofree(pkt);
303 FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
305 av_destruct_packet(pkt);
308 FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
310 return av_new_packet(pkt, size);
313 FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
315 return av_dup_packet(pkt);
318 FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
323 FF_SYMVER(void, av_init_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
325 av_log(NULL, AV_LOG_WARNING, "Diverting av_*_packet function calls to libavcodec. Recompile to improve performance\n");
330 int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
332 int ret= av_new_packet(pkt, size);
337 pkt->pos= avio_tell(s);
339 ret= avio_read(s, pkt->data, size);
343 av_shrink_packet(pkt, ret);
348 int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
353 return av_get_packet(s, pkt, size);
354 old_size = pkt->size;
355 ret = av_grow_packet(pkt, size);
358 ret = avio_read(s, pkt->data + old_size, size);
359 av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
364 int av_filename_number_test(const char *filename)
367 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
370 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
372 AVProbeData lpd = *pd;
373 AVInputFormat *fmt1 = NULL, *fmt;
376 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
377 int id3len = ff_id3v2_tag_len(lpd.buf);
378 if (lpd.buf_size > id3len + 16) {
380 lpd.buf_size -= id3len;
385 while ((fmt1 = av_iformat_next(fmt1))) {
386 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
389 if (fmt1->read_probe) {
390 score = fmt1->read_probe(&lpd);
391 } else if (fmt1->extensions) {
392 if (av_match_ext(lpd.filename, fmt1->extensions)) {
396 if (score > *score_max) {
399 }else if (score == *score_max)
405 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
407 return av_probe_input_format2(pd, is_opened, &score);
410 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
412 static const struct {
413 const char *name; enum CodecID id; enum AVMediaType type;
415 { "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
416 { "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
417 { "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
418 { "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
419 { "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
420 { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
421 { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
422 { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
425 AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
429 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
430 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
431 for (i = 0; fmt_id_type[i].name; i++) {
432 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
433 st->codec->codec_id = fmt_id_type[i].id;
434 st->codec->codec_type = fmt_id_type[i].type;
442 /************************************************************/
443 /* input media file */
446 * Open a media file from an IO stream. 'fmt' must be specified.
448 int av_open_input_stream(AVFormatContext **ic_ptr,
449 AVIOContext *pb, const char *filename,
450 AVInputFormat *fmt, AVFormatParameters *ap)
454 AVFormatParameters default_ap;
458 memset(ap, 0, sizeof(default_ap));
461 if(!ap->prealloced_context)
462 ic = avformat_alloc_context();
466 err = AVERROR(ENOMEM);
471 ic->duration = AV_NOPTS_VALUE;
472 ic->start_time = AV_NOPTS_VALUE;
473 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
475 /* allocate private data */
476 if (fmt->priv_data_size > 0) {
477 ic->priv_data = av_mallocz(fmt->priv_data_size);
478 if (!ic->priv_data) {
479 err = AVERROR(ENOMEM);
483 ic->priv_data = NULL;
486 // e.g. AVFMT_NOFILE formats will not have a AVIOContext
488 ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
490 if (ic->iformat->read_header) {
491 err = ic->iformat->read_header(ic, ap);
496 if (pb && !ic->data_offset)
497 ic->data_offset = avio_tell(ic->pb);
499 #if FF_API_OLD_METADATA
500 ff_metadata_demux_compat(ic);
503 ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
510 av_freep(&ic->priv_data);
511 for(i=0;i<ic->nb_streams;i++) {
512 AVStream *st = ic->streams[i];
514 av_free(st->priv_data);
515 av_free(st->codec->extradata);
527 /** size of probe buffer, for guessing file type from file contents */
528 #define PROBE_BUF_MIN 2048
529 #define PROBE_BUF_MAX (1<<20)
531 int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
532 const char *filename, void *logctx,
533 unsigned int offset, unsigned int max_probe_size)
535 AVProbeData pd = { filename ? filename : "", NULL, -offset };
536 unsigned char *buf = NULL;
537 int ret = 0, probe_size;
539 if (!max_probe_size) {
540 max_probe_size = PROBE_BUF_MAX;
541 } else if (max_probe_size > PROBE_BUF_MAX) {
542 max_probe_size = PROBE_BUF_MAX;
543 } else if (max_probe_size < PROBE_BUF_MIN) {
544 return AVERROR(EINVAL);
547 if (offset >= max_probe_size) {
548 return AVERROR(EINVAL);
551 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
552 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
553 int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
554 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
556 if (probe_size < offset) {
560 /* read probe data */
561 buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
562 if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
563 /* fail if error was not end of file, otherwise, lower score */
564 if (ret != AVERROR_EOF) {
569 ret = 0; /* error was end of file, nothing read */
572 pd.buf = &buf[offset];
574 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
576 /* guess file format */
577 *fmt = av_probe_input_format2(&pd, 1, &score);
579 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
580 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
582 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
588 return AVERROR_INVALIDDATA;
591 /* rewind. reuse probe buffer to avoid seeking */
592 if ((ret = ffio_rewind_with_probe_data(pb, buf, pd.buf_size)) < 0)
598 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
601 AVFormatParameters *ap)
604 AVProbeData probe_data, *pd = &probe_data;
605 AVIOContext *pb = NULL;
606 void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
610 pd->filename = filename;
615 /* guess format if no file can be opened */
616 fmt = av_probe_input_format(pd, 0);
619 /* Do not open file if the format does not need it. XXX: specific
620 hack needed to handle RTSP/TCP */
621 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
622 /* if no file needed do not try to open one */
623 if ((err=avio_open(&pb, filename, URL_RDONLY)) < 0) {
627 ffio_set_buf_size(pb, buf_size);
629 if (!fmt && (err = av_probe_input_buffer(pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
634 /* if still no format found, error */
636 err = AVERROR_INVALIDDATA;
640 /* check filename in case an image number is expected */
641 if (fmt->flags & AVFMT_NEEDNUMBER) {
642 if (!av_filename_number_test(filename)) {
643 err = AVERROR_NUMEXPECTED;
647 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
655 if (ap && ap->prealloced_context)
662 /*******************************************************/
664 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
665 AVPacketList **plast_pktl){
666 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
671 (*plast_pktl)->next = pktl;
673 *packet_buffer = pktl;
675 /* add the packet in the buffered packet list */
681 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
687 AVPacketList *pktl = s->raw_packet_buffer;
691 if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
692 !s->streams[pkt->stream_index]->probe_packets ||
693 s->raw_packet_buffer_remaining_size < pkt->size){
694 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
697 s->raw_packet_buffer = pktl->next;
698 s->raw_packet_buffer_remaining_size += pkt->size;
705 ret= s->iformat->read_packet(s, pkt);
707 if (!pktl || ret == AVERROR(EAGAIN))
709 for (i = 0; i < s->nb_streams; i++)
710 s->streams[i]->probe_packets = 0;
713 st= s->streams[pkt->stream_index];
715 switch(st->codec->codec_type){
716 case AVMEDIA_TYPE_VIDEO:
717 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
719 case AVMEDIA_TYPE_AUDIO:
720 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
722 case AVMEDIA_TYPE_SUBTITLE:
723 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
727 if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
731 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
732 s->raw_packet_buffer_remaining_size -= pkt->size;
734 if(st->codec->codec_id == CODEC_ID_PROBE){
735 AVProbeData *pd = &st->probe_data;
736 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
739 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
740 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
741 pd->buf_size += pkt->size;
742 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
744 if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
745 //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
746 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
747 if(st->codec->codec_id != CODEC_ID_PROBE){
750 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
757 /**********************************************************/
760 * Get the number of samples of an audio frame. Return -1 on error.
762 static int get_audio_frame_size(AVCodecContext *enc, int size)
766 if(enc->codec_id == CODEC_ID_VORBIS)
769 if (enc->frame_size <= 1) {
770 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
772 if (bits_per_sample) {
773 if (enc->channels == 0)
775 frame_size = (size << 3) / (bits_per_sample * enc->channels);
777 /* used for example by ADPCM codecs */
778 if (enc->bit_rate == 0)
780 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
783 frame_size = enc->frame_size;
790 * Return the frame duration in seconds. Return 0 if not available.
792 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
793 AVCodecParserContext *pc, AVPacket *pkt)
799 switch(st->codec->codec_type) {
800 case AVMEDIA_TYPE_VIDEO:
801 if(st->time_base.num*1000LL > st->time_base.den){
802 *pnum = st->time_base.num;
803 *pden = st->time_base.den;
804 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
805 *pnum = st->codec->time_base.num;
806 *pden = st->codec->time_base.den;
807 if (pc && pc->repeat_pict) {
808 *pnum = (*pnum) * (1 + pc->repeat_pict);
810 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
811 //Thus if we have no parser in such case leave duration undefined.
812 if(st->codec->ticks_per_frame>1 && !pc){
817 case AVMEDIA_TYPE_AUDIO:
818 frame_size = get_audio_frame_size(st->codec, pkt->size);
819 if (frame_size <= 0 || st->codec->sample_rate <= 0)
822 *pden = st->codec->sample_rate;
829 static int is_intra_only(AVCodecContext *enc){
830 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
832 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
833 switch(enc->codec_id){
835 case CODEC_ID_MJPEGB:
837 case CODEC_ID_RAWVIDEO:
838 case CODEC_ID_DVVIDEO:
839 case CODEC_ID_HUFFYUV:
840 case CODEC_ID_FFVHUFF:
845 case CODEC_ID_JPEG2000:
853 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
854 int64_t dts, int64_t pts)
856 AVStream *st= s->streams[stream_index];
857 AVPacketList *pktl= s->packet_buffer;
859 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
862 st->first_dts= dts - st->cur_dts;
865 for(; pktl; pktl= pktl->next){
866 if(pktl->pkt.stream_index != stream_index)
868 //FIXME think more about this check
869 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
870 pktl->pkt.pts += st->first_dts;
872 if(pktl->pkt.dts != AV_NOPTS_VALUE)
873 pktl->pkt.dts += st->first_dts;
875 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
876 st->start_time= pktl->pkt.pts;
878 if (st->start_time == AV_NOPTS_VALUE)
879 st->start_time = pts;
882 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
884 AVPacketList *pktl= s->packet_buffer;
887 if(st->first_dts != AV_NOPTS_VALUE){
888 cur_dts= st->first_dts;
889 for(; pktl; pktl= pktl->next){
890 if(pktl->pkt.stream_index == pkt->stream_index){
891 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
893 cur_dts -= pkt->duration;
896 pktl= s->packet_buffer;
897 st->first_dts = cur_dts;
898 }else if(st->cur_dts)
901 for(; pktl; pktl= pktl->next){
902 if(pktl->pkt.stream_index != pkt->stream_index)
904 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
905 && !pktl->pkt.duration){
906 pktl->pkt.dts= cur_dts;
907 if(!st->codec->has_b_frames)
908 pktl->pkt.pts= cur_dts;
909 cur_dts += pkt->duration;
910 pktl->pkt.duration= pkt->duration;
914 if(st->first_dts == AV_NOPTS_VALUE)
915 st->cur_dts= cur_dts;
918 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
919 AVCodecParserContext *pc, AVPacket *pkt)
921 int num, den, presentation_delayed, delay, i;
924 if (s->flags & AVFMT_FLAG_NOFILLIN)
927 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
928 pkt->dts= AV_NOPTS_VALUE;
930 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
931 //FIXME Set low_delay = 0 when has_b_frames = 1
932 st->codec->has_b_frames = 1;
934 /* do we have a video B-frame ? */
935 delay= st->codec->has_b_frames;
936 presentation_delayed = 0;
938 // ignore delay caused by frame threading so that the mpeg2-without-dts
939 // warning will not trigger
940 if (delay && st->codec->active_thread_type&FF_THREAD_FRAME)
941 delay -= st->codec->thread_count-1;
943 /* XXX: need has_b_frame, but cannot get it if the codec is
946 pc && pc->pict_type != FF_B_TYPE)
947 presentation_delayed = 1;
949 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
950 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
951 pkt->dts -= 1LL<<st->pts_wrap_bits;
954 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
955 // we take the conservative approach and discard both
956 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
957 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
958 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
959 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
962 if (pkt->duration == 0) {
963 compute_frame_duration(&num, &den, st, pc, pkt);
965 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
967 if(pkt->duration != 0 && s->packet_buffer)
968 update_initial_durations(s, st, pkt);
972 /* correct timestamps with byte offset if demuxers only have timestamps
973 on packet boundaries */
974 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
975 /* this will estimate bitrate based on this frame's duration and size */
976 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
977 if(pkt->pts != AV_NOPTS_VALUE)
979 if(pkt->dts != AV_NOPTS_VALUE)
983 if (pc && pc->dts_sync_point >= 0) {
984 // we have synchronization info from the parser
985 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
987 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
988 if (pkt->dts != AV_NOPTS_VALUE) {
989 // got DTS from the stream, update reference timestamp
990 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
991 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
992 } else if (st->reference_dts != AV_NOPTS_VALUE) {
993 // compute DTS based on reference timestamp
994 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
995 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
997 if (pc->dts_sync_point > 0)
998 st->reference_dts = pkt->dts; // new reference
1002 /* This may be redundant, but it should not hurt. */
1003 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
1004 presentation_delayed = 1;
1006 // 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);
1007 /* interpolate PTS and DTS if they are not present */
1008 //We skip H264 currently because delay and has_b_frames are not reliably set
1009 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
1010 if (presentation_delayed) {
1011 /* DTS = decompression timestamp */
1012 /* PTS = presentation timestamp */
1013 if (pkt->dts == AV_NOPTS_VALUE)
1014 pkt->dts = st->last_IP_pts;
1015 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1016 if (pkt->dts == AV_NOPTS_VALUE)
1017 pkt->dts = st->cur_dts;
1019 /* this is tricky: the dts must be incremented by the duration
1020 of the frame we are displaying, i.e. the last I- or P-frame */
1021 if (st->last_IP_duration == 0)
1022 st->last_IP_duration = pkt->duration;
1023 if(pkt->dts != AV_NOPTS_VALUE)
1024 st->cur_dts = pkt->dts + st->last_IP_duration;
1025 st->last_IP_duration = pkt->duration;
1026 st->last_IP_pts= pkt->pts;
1027 /* cannot compute PTS if not present (we can compute it only
1028 by knowing the future */
1029 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1030 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1031 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1032 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1033 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1034 pkt->pts += pkt->duration;
1035 // 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);
1039 /* presentation is not delayed : PTS and DTS are the same */
1040 if(pkt->pts == AV_NOPTS_VALUE)
1041 pkt->pts = pkt->dts;
1042 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1043 if(pkt->pts == AV_NOPTS_VALUE)
1044 pkt->pts = st->cur_dts;
1045 pkt->dts = pkt->pts;
1046 if(pkt->pts != AV_NOPTS_VALUE)
1047 st->cur_dts = pkt->pts + pkt->duration;
1051 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1052 st->pts_buffer[0]= pkt->pts;
1053 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1054 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1055 if(pkt->dts == AV_NOPTS_VALUE)
1056 pkt->dts= st->pts_buffer[0];
1057 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1058 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1060 if(pkt->dts > st->cur_dts)
1061 st->cur_dts = pkt->dts;
1064 // 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);
1067 if(is_intra_only(st->codec))
1068 pkt->flags |= AV_PKT_FLAG_KEY;
1071 /* keyframe computation */
1072 if (pc->key_frame == 1)
1073 pkt->flags |= AV_PKT_FLAG_KEY;
1074 else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1075 pkt->flags |= AV_PKT_FLAG_KEY;
1078 pkt->convergence_duration = pc->convergence_duration;
1082 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1087 av_init_packet(pkt);
1090 /* select current input stream component */
1093 if (!st->need_parsing || !st->parser) {
1094 /* no parsing needed: we just output the packet as is */
1095 /* raw data support */
1096 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1097 compute_pkt_fields(s, st, NULL, pkt);
1099 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1100 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1101 ff_reduce_index(s, st->index);
1102 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1105 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1106 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1107 st->cur_ptr, st->cur_len,
1108 st->cur_pkt.pts, st->cur_pkt.dts,
1110 st->cur_pkt.pts = AV_NOPTS_VALUE;
1111 st->cur_pkt.dts = AV_NOPTS_VALUE;
1112 /* increment read pointer */
1116 /* return packet if any */
1120 pkt->stream_index = st->index;
1121 pkt->pts = st->parser->pts;
1122 pkt->dts = st->parser->dts;
1123 pkt->pos = st->parser->pos;
1124 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1126 pkt->destruct= st->cur_pkt.destruct;
1127 st->cur_pkt.destruct= NULL;
1128 st->cur_pkt.data = NULL;
1129 assert(st->cur_len == 0);
1131 pkt->destruct = NULL;
1133 compute_pkt_fields(s, st, st->parser, pkt);
1135 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1136 ff_reduce_index(s, st->index);
1137 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1138 0, 0, AVINDEX_KEYFRAME);
1145 av_free_packet(&st->cur_pkt);
1150 /* read next packet */
1151 ret = av_read_packet(s, &cur_pkt);
1153 if (ret == AVERROR(EAGAIN))
1155 /* return the last frames, if any */
1156 for(i = 0; i < s->nb_streams; i++) {
1158 if (st->parser && st->need_parsing) {
1159 av_parser_parse2(st->parser, st->codec,
1160 &pkt->data, &pkt->size,
1162 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1168 /* no more packets: really terminate parsing */
1171 st = s->streams[cur_pkt.stream_index];
1172 st->cur_pkt= cur_pkt;
1174 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1175 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1176 st->cur_pkt.pts < st->cur_pkt.dts){
1177 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1178 st->cur_pkt.stream_index,
1182 // av_free_packet(&st->cur_pkt);
1186 if(s->debug & FF_FDEBUG_TS)
1187 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1188 st->cur_pkt.stream_index,
1192 st->cur_pkt.duration,
1196 st->cur_ptr = st->cur_pkt.data;
1197 st->cur_len = st->cur_pkt.size;
1198 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1199 st->parser = av_parser_init(st->codec->codec_id);
1201 /* no parser available: just output the raw packets */
1202 st->need_parsing = AVSTREAM_PARSE_NONE;
1203 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1204 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1205 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1206 st->parser->flags |= PARSER_FLAG_ONCE;
1211 if(s->debug & FF_FDEBUG_TS)
1212 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1223 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1227 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1230 pktl = s->packet_buffer;
1232 AVPacket *next_pkt= &pktl->pkt;
1234 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1235 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1236 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1237 if( pktl->pkt.stream_index == next_pkt->stream_index
1238 && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1239 && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1240 next_pkt->pts= pktl->pkt.dts;
1244 pktl = s->packet_buffer;
1247 if( next_pkt->pts != AV_NOPTS_VALUE
1248 || next_pkt->dts == AV_NOPTS_VALUE
1250 /* read packet from packet buffer, if there is data */
1252 s->packet_buffer = pktl->next;
1258 int ret= av_read_frame_internal(s, pkt);
1260 if(pktl && ret != AVERROR(EAGAIN)){
1267 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1268 &s->packet_buffer_end)) < 0)
1269 return AVERROR(ENOMEM);
1271 assert(!s->packet_buffer);
1272 return av_read_frame_internal(s, pkt);
1277 /* XXX: suppress the packet queue */
1278 static void flush_packet_queue(AVFormatContext *s)
1283 pktl = s->packet_buffer;
1286 s->packet_buffer = pktl->next;
1287 av_free_packet(&pktl->pkt);
1290 while(s->raw_packet_buffer){
1291 pktl = s->raw_packet_buffer;
1292 s->raw_packet_buffer = pktl->next;
1293 av_free_packet(&pktl->pkt);
1296 s->packet_buffer_end=
1297 s->raw_packet_buffer_end= NULL;
1298 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1301 /*******************************************************/
1304 int av_find_default_stream_index(AVFormatContext *s)
1306 int first_audio_index = -1;
1310 if (s->nb_streams <= 0)
1312 for(i = 0; i < s->nb_streams; i++) {
1314 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1317 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1318 first_audio_index = i;
1320 return first_audio_index >= 0 ? first_audio_index : 0;
1324 * Flush the frame reader.
1326 void ff_read_frame_flush(AVFormatContext *s)
1331 flush_packet_queue(s);
1335 /* for each stream, reset read state */
1336 for(i = 0; i < s->nb_streams; i++) {
1340 av_parser_close(st->parser);
1342 av_free_packet(&st->cur_pkt);
1344 st->last_IP_pts = AV_NOPTS_VALUE;
1345 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1346 st->reference_dts = AV_NOPTS_VALUE;
1351 st->probe_packets = MAX_PROBE_PACKETS;
1353 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1354 st->pts_buffer[j]= AV_NOPTS_VALUE;
1358 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1361 for(i = 0; i < s->nb_streams; i++) {
1362 AVStream *st = s->streams[i];
1364 st->cur_dts = av_rescale(timestamp,
1365 st->time_base.den * (int64_t)ref_st->time_base.num,
1366 st->time_base.num * (int64_t)ref_st->time_base.den);
1370 void ff_reduce_index(AVFormatContext *s, int stream_index)
1372 AVStream *st= s->streams[stream_index];
1373 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1375 if((unsigned)st->nb_index_entries >= max_entries){
1377 for(i=0; 2*i<st->nb_index_entries; i++)
1378 st->index_entries[i]= st->index_entries[2*i];
1379 st->nb_index_entries= i;
1383 int ff_add_index_entry(AVIndexEntry **index_entries,
1384 int *nb_index_entries,
1385 unsigned int *index_entries_allocated_size,
1386 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1388 AVIndexEntry *entries, *ie;
1391 if((unsigned)*nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1394 entries = av_fast_realloc(*index_entries,
1395 index_entries_allocated_size,
1396 (*nb_index_entries + 1) *
1397 sizeof(AVIndexEntry));
1401 *index_entries= entries;
1403 index= ff_index_search_timestamp(*index_entries, *nb_index_entries, timestamp, AVSEEK_FLAG_ANY);
1406 index= (*nb_index_entries)++;
1407 ie= &entries[index];
1408 assert(index==0 || ie[-1].timestamp < timestamp);
1410 ie= &entries[index];
1411 if(ie->timestamp != timestamp){
1412 if(ie->timestamp <= timestamp)
1414 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(*nb_index_entries - index));
1415 (*nb_index_entries)++;
1416 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1417 distance= ie->min_distance;
1421 ie->timestamp = timestamp;
1422 ie->min_distance= distance;
1429 int av_add_index_entry(AVStream *st,
1430 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1432 return ff_add_index_entry(&st->index_entries, &st->nb_index_entries,
1433 &st->index_entries_allocated_size, pos,
1434 timestamp, size, distance, flags);
1437 int ff_index_search_timestamp(const AVIndexEntry *entries, int nb_entries,
1438 int64_t wanted_timestamp, int flags)
1446 //optimize appending index entries at the end
1447 if(b && entries[b-1].timestamp < wanted_timestamp)
1452 timestamp = entries[m].timestamp;
1453 if(timestamp >= wanted_timestamp)
1455 if(timestamp <= wanted_timestamp)
1458 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1460 if(!(flags & AVSEEK_FLAG_ANY)){
1461 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1462 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1471 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1474 return ff_index_search_timestamp(st->index_entries, st->nb_index_entries,
1475 wanted_timestamp, flags);
1480 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1481 AVInputFormat *avif= s->iformat;
1482 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1483 int64_t ts_min, ts_max, ts;
1488 if (stream_index < 0)
1492 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1496 ts_min= AV_NOPTS_VALUE;
1497 pos_limit= -1; //gcc falsely says it may be uninitialized
1499 st= s->streams[stream_index];
1500 if(st->index_entries){
1503 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()
1504 index= FFMAX(index, 0);
1505 e= &st->index_entries[index];
1507 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1509 ts_min= e->timestamp;
1511 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1518 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1519 assert(index < st->nb_index_entries);
1521 e= &st->index_entries[index];
1522 assert(e->timestamp >= target_ts);
1524 ts_max= e->timestamp;
1525 pos_limit= pos_max - e->min_distance;
1527 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1528 pos_max,pos_limit, ts_max);
1533 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1538 if ((ret = avio_seek(s->pb, pos, SEEK_SET)) < 0)
1541 av_update_cur_dts(s, st, ts);
1546 int64_t av_gen_search(AVFormatContext *s, int stream_index, int64_t target_ts, int64_t pos_min, int64_t pos_max, int64_t pos_limit, int64_t ts_min, int64_t ts_max, int flags, int64_t *ts_ret, int64_t (*read_timestamp)(struct AVFormatContext *, int , int64_t *, int64_t )){
1548 int64_t start_pos, filesize;
1552 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1555 if(ts_min == AV_NOPTS_VALUE){
1556 pos_min = s->data_offset;
1557 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1558 if (ts_min == AV_NOPTS_VALUE)
1562 if(ts_max == AV_NOPTS_VALUE){
1564 filesize = avio_size(s->pb);
1565 pos_max = filesize - 1;
1568 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1570 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1571 if (ts_max == AV_NOPTS_VALUE)
1575 int64_t tmp_pos= pos_max + 1;
1576 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1577 if(tmp_ts == AV_NOPTS_VALUE)
1581 if(tmp_pos >= filesize)
1587 if(ts_min > ts_max){
1589 }else if(ts_min == ts_max){
1594 while (pos_min < pos_limit) {
1596 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1600 assert(pos_limit <= pos_max);
1603 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1604 // interpolate position (better than dichotomy)
1605 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1606 + pos_min - approximate_keyframe_distance;
1607 }else if(no_change==1){
1608 // bisection, if interpolation failed to change min or max pos last time
1609 pos = (pos_min + pos_limit)>>1;
1611 /* linear search if bisection failed, can only happen if there
1612 are very few or no keyframes between min/max */
1617 else if(pos > pos_limit)
1621 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1627 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1628 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1629 start_pos, no_change);
1631 if(ts == AV_NOPTS_VALUE){
1632 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1635 assert(ts != AV_NOPTS_VALUE);
1636 if (target_ts <= ts) {
1637 pos_limit = start_pos - 1;
1641 if (target_ts >= ts) {
1647 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1648 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1651 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1653 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1654 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1655 pos, ts_min, target_ts, ts_max);
1661 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1662 int64_t pos_min, pos_max;
1666 if (stream_index < 0)
1669 st= s->streams[stream_index];
1672 pos_min = s->data_offset;
1673 pos_max = avio_size(s->pb) - 1;
1675 if (pos < pos_min) pos= pos_min;
1676 else if(pos > pos_max) pos= pos_max;
1678 avio_seek(s->pb, pos, SEEK_SET);
1681 av_update_cur_dts(s, st, ts);
1686 static int av_seek_frame_generic(AVFormatContext *s,
1687 int stream_index, int64_t timestamp, int flags)
1694 st = s->streams[stream_index];
1696 index = av_index_search_timestamp(st, timestamp, flags);
1698 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1701 if(index < 0 || index==st->nb_index_entries-1){
1705 if(st->nb_index_entries){
1706 assert(st->index_entries);
1707 ie= &st->index_entries[st->nb_index_entries-1];
1708 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1710 av_update_cur_dts(s, st, ie->timestamp);
1712 if ((ret = avio_seek(s->pb, s->data_offset, SEEK_SET)) < 0)
1718 ret = av_read_frame(s, &pkt);
1719 }while(ret == AVERROR(EAGAIN));
1722 av_free_packet(&pkt);
1723 if(stream_index == pkt.stream_index){
1724 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1728 index = av_index_search_timestamp(st, timestamp, flags);
1733 ff_read_frame_flush(s);
1734 if (s->iformat->read_seek){
1735 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1738 ie = &st->index_entries[index];
1739 if ((ret = avio_seek(s->pb, ie->pos, SEEK_SET)) < 0)
1741 av_update_cur_dts(s, st, ie->timestamp);
1746 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1751 ff_read_frame_flush(s);
1753 if(flags & AVSEEK_FLAG_BYTE)
1754 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1756 if(stream_index < 0){
1757 stream_index= av_find_default_stream_index(s);
1758 if(stream_index < 0)
1761 st= s->streams[stream_index];
1762 /* timestamp for default must be expressed in AV_TIME_BASE units */
1763 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1766 /* first, we try the format specific seek */
1767 if (s->iformat->read_seek)
1768 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1775 if(s->iformat->read_timestamp)
1776 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1778 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1781 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1783 if(min_ts > ts || max_ts < ts)
1786 ff_read_frame_flush(s);
1788 if (s->iformat->read_seek2)
1789 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1791 if(s->iformat->read_timestamp){
1792 //try to seek via read_timestamp()
1795 //Fallback to old API if new is not implemented but old is
1796 //Note the old has somewat different sematics
1797 if(s->iformat->read_seek || 1)
1798 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1800 // try some generic seek like av_seek_frame_generic() but with new ts semantics
1803 /*******************************************************/
1806 * Return TRUE if the stream has accurate duration in any stream.
1808 * @return TRUE if the stream has accurate duration for at least one component.
1810 static int av_has_duration(AVFormatContext *ic)
1815 for(i = 0;i < ic->nb_streams; i++) {
1816 st = ic->streams[i];
1817 if (st->duration != AV_NOPTS_VALUE)
1824 * Estimate the stream timings from the one of each components.
1826 * Also computes the global bitrate if possible.
1828 static void av_update_stream_timings(AVFormatContext *ic)
1830 int64_t start_time, start_time1, end_time, end_time1;
1831 int64_t duration, duration1;
1835 start_time = INT64_MAX;
1836 end_time = INT64_MIN;
1837 duration = INT64_MIN;
1838 for(i = 0;i < ic->nb_streams; i++) {
1839 st = ic->streams[i];
1840 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1841 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1842 if (start_time1 < start_time)
1843 start_time = start_time1;
1844 if (st->duration != AV_NOPTS_VALUE) {
1845 end_time1 = start_time1
1846 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1847 if (end_time1 > end_time)
1848 end_time = end_time1;
1851 if (st->duration != AV_NOPTS_VALUE) {
1852 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1853 if (duration1 > duration)
1854 duration = duration1;
1857 if (start_time != INT64_MAX) {
1858 ic->start_time = start_time;
1859 if (end_time != INT64_MIN) {
1860 if (end_time - start_time > duration)
1861 duration = end_time - start_time;
1864 if (duration != INT64_MIN) {
1865 ic->duration = duration;
1866 if (ic->file_size > 0) {
1867 /* compute the bitrate */
1868 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1869 (double)ic->duration;
1874 static void fill_all_stream_timings(AVFormatContext *ic)
1879 av_update_stream_timings(ic);
1880 for(i = 0;i < ic->nb_streams; i++) {
1881 st = ic->streams[i];
1882 if (st->start_time == AV_NOPTS_VALUE) {
1883 if(ic->start_time != AV_NOPTS_VALUE)
1884 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1885 if(ic->duration != AV_NOPTS_VALUE)
1886 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1891 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1893 int64_t filesize, duration;
1897 /* if bit_rate is already set, we believe it */
1898 if (ic->bit_rate <= 0) {
1900 for(i=0;i<ic->nb_streams;i++) {
1901 st = ic->streams[i];
1902 if (st->codec->bit_rate > 0)
1903 bit_rate += st->codec->bit_rate;
1905 ic->bit_rate = bit_rate;
1908 /* if duration is already set, we believe it */
1909 if (ic->duration == AV_NOPTS_VALUE &&
1910 ic->bit_rate != 0 &&
1911 ic->file_size != 0) {
1912 filesize = ic->file_size;
1914 for(i = 0; i < ic->nb_streams; i++) {
1915 st = ic->streams[i];
1916 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1917 if (st->duration == AV_NOPTS_VALUE)
1918 st->duration = duration;
1924 #define DURATION_MAX_READ_SIZE 250000
1925 #define DURATION_MAX_RETRY 3
1927 /* only usable for MPEG-PS streams */
1928 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1930 AVPacket pkt1, *pkt = &pkt1;
1932 int read_size, i, ret;
1934 int64_t filesize, offset, duration;
1939 /* flush packet queue */
1940 flush_packet_queue(ic);
1942 for (i=0; i<ic->nb_streams; i++) {
1943 st = ic->streams[i];
1944 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1945 av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1948 av_parser_close(st->parser);
1950 av_free_packet(&st->cur_pkt);
1954 /* estimate the end time (duration) */
1955 /* XXX: may need to support wrapping */
1956 filesize = ic->file_size;
1957 end_time = AV_NOPTS_VALUE;
1959 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1963 avio_seek(ic->pb, offset, SEEK_SET);
1966 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1970 ret = av_read_packet(ic, pkt);
1971 }while(ret == AVERROR(EAGAIN));
1974 read_size += pkt->size;
1975 st = ic->streams[pkt->stream_index];
1976 if (pkt->pts != AV_NOPTS_VALUE &&
1977 (st->start_time != AV_NOPTS_VALUE ||
1978 st->first_dts != AV_NOPTS_VALUE)) {
1979 duration = end_time = pkt->pts;
1980 if (st->start_time != AV_NOPTS_VALUE) duration -= st->start_time;
1981 else duration -= st->first_dts;
1983 duration += 1LL<<st->pts_wrap_bits;
1985 if (st->duration == AV_NOPTS_VALUE ||
1986 st->duration < duration)
1987 st->duration = duration;
1990 av_free_packet(pkt);
1992 }while( end_time==AV_NOPTS_VALUE
1993 && filesize > (DURATION_MAX_READ_SIZE<<retry)
1994 && ++retry <= DURATION_MAX_RETRY);
1996 fill_all_stream_timings(ic);
1998 avio_seek(ic->pb, old_offset, SEEK_SET);
1999 for (i=0; i<ic->nb_streams; i++) {
2001 st->cur_dts= st->first_dts;
2002 st->last_IP_pts = AV_NOPTS_VALUE;
2006 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
2010 /* get the file size, if possible */
2011 if (ic->iformat->flags & AVFMT_NOFILE) {
2014 file_size = avio_size(ic->pb);
2018 ic->file_size = file_size;
2020 if ((!strcmp(ic->iformat->name, "mpeg") ||
2021 !strcmp(ic->iformat->name, "mpegts")) &&
2022 file_size && !url_is_streamed(ic->pb)) {
2023 /* get accurate estimate from the PTSes */
2024 av_estimate_timings_from_pts(ic, old_offset);
2025 } else if (av_has_duration(ic)) {
2026 /* at least one component has timings - we use them for all
2028 fill_all_stream_timings(ic);
2030 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2031 /* less precise: use bitrate info */
2032 av_estimate_timings_from_bit_rate(ic);
2034 av_update_stream_timings(ic);
2040 for(i = 0;i < ic->nb_streams; i++) {
2041 st = ic->streams[i];
2042 printf("%d: start_time: %0.3f duration: %0.3f\n",
2043 i, (double)st->start_time / AV_TIME_BASE,
2044 (double)st->duration / AV_TIME_BASE);
2046 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2047 (double)ic->start_time / AV_TIME_BASE,
2048 (double)ic->duration / AV_TIME_BASE,
2049 ic->bit_rate / 1000);
2054 static int has_codec_parameters(AVCodecContext *enc)
2057 switch(enc->codec_type) {
2058 case AVMEDIA_TYPE_AUDIO:
2059 val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2060 if(!enc->frame_size &&
2061 (enc->codec_id == CODEC_ID_VORBIS ||
2062 enc->codec_id == CODEC_ID_AAC ||
2063 enc->codec_id == CODEC_ID_MP1 ||
2064 enc->codec_id == CODEC_ID_MP2 ||
2065 enc->codec_id == CODEC_ID_MP3 ||
2066 enc->codec_id == CODEC_ID_SPEEX))
2069 case AVMEDIA_TYPE_VIDEO:
2070 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2076 return enc->codec_id != CODEC_ID_NONE && val != 0;
2079 static int has_decode_delay_been_guessed(AVStream *st)
2081 return st->codec->codec_id != CODEC_ID_H264 ||
2082 st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2085 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2089 int got_picture, data_size, ret=0;
2092 if(!st->codec->codec){
2093 codec = avcodec_find_decoder(st->codec->codec_id);
2096 ret = avcodec_open(st->codec, codec);
2101 if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2102 switch(st->codec->codec_type) {
2103 case AVMEDIA_TYPE_VIDEO:
2104 avcodec_get_frame_defaults(&picture);
2105 ret = avcodec_decode_video2(st->codec, &picture,
2106 &got_picture, avpkt);
2108 case AVMEDIA_TYPE_AUDIO:
2109 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2110 samples = av_malloc(data_size);
2113 ret = avcodec_decode_audio3(st->codec, samples,
2125 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2127 while (tags->id != CODEC_ID_NONE) {
2135 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2138 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2139 if(tag == tags[i].tag)
2142 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2143 if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2146 return CODEC_ID_NONE;
2149 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2152 for(i=0; tags && tags[i]; i++){
2153 int tag= ff_codec_get_tag(tags[i], id);
2159 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2162 for(i=0; tags && tags[i]; i++){
2163 enum CodecID id= ff_codec_get_id(tags[i], tag);
2164 if(id!=CODEC_ID_NONE) return id;
2166 return CODEC_ID_NONE;
2169 static void compute_chapters_end(AVFormatContext *s)
2173 for (i=0; i+1<s->nb_chapters; i++)
2174 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2175 assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2176 assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2177 s->chapters[i]->end = s->chapters[i+1]->start;
2180 if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2181 assert(s->start_time != AV_NOPTS_VALUE);
2182 assert(s->duration > 0);
2183 s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2185 s->chapters[i]->time_base);
2189 static int get_std_framerate(int i){
2190 if(i<60*12) return i*1001;
2191 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2195 * Is the time base unreliable.
2196 * This is a heuristic to balance between quick acceptance of the values in
2197 * the headers vs. some extra checks.
2198 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2199 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2200 * And there are "variable" fps files this needs to detect as well.
2202 static int tb_unreliable(AVCodecContext *c){
2203 if( c->time_base.den >= 101L*c->time_base.num
2204 || c->time_base.den < 5L*c->time_base.num
2205 /* || c->codec_tag == AV_RL32("DIVX")
2206 || c->codec_tag == AV_RL32("XVID")*/
2207 || c->codec_id == CODEC_ID_MPEG2VIDEO
2208 || c->codec_id == CODEC_ID_H264
2214 int av_find_stream_info(AVFormatContext *ic)
2216 int i, count, ret, read_size, j;
2218 AVPacket pkt1, *pkt;
2219 int64_t old_offset = avio_tell(ic->pb);
2221 for(i=0;i<ic->nb_streams;i++) {
2223 st = ic->streams[i];
2224 if (st->codec->codec_id == CODEC_ID_AAC) {
2225 st->codec->sample_rate = 0;
2226 st->codec->frame_size = 0;
2227 st->codec->channels = 0;
2229 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2230 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2231 /* if(!st->time_base.num)
2233 if(!st->codec->time_base.num)
2234 st->codec->time_base= st->time_base;
2236 //only for the split stuff
2237 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2238 st->parser = av_parser_init(st->codec->codec_id);
2239 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2240 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2243 assert(!st->codec->codec);
2244 codec = avcodec_find_decoder(st->codec->codec_id);
2246 /* Force decoding of at least one frame of codec data
2247 * this makes sure the codec initializes the channel configuration
2248 * and does not trust the values from the container.
2250 if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2251 st->codec->channels = 0;
2253 /* Ensure that subtitle_header is properly set. */
2254 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2255 && codec && !st->codec->codec)
2256 avcodec_open(st->codec, codec);
2258 //try to just open decoders, in case this is enough to get parameters
2259 if(!has_codec_parameters(st->codec)){
2260 if (codec && !st->codec->codec)
2261 avcodec_open(st->codec, codec);
2265 for (i=0; i<ic->nb_streams; i++) {
2266 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2272 if(url_interrupt_cb()){
2274 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2278 /* check if one codec still needs to be handled */
2279 for(i=0;i<ic->nb_streams;i++) {
2280 st = ic->streams[i];
2281 if (!has_codec_parameters(st->codec))
2283 /* variable fps and no guess at the real fps */
2284 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2285 && st->info->duration_count<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2287 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2289 if(st->first_dts == AV_NOPTS_VALUE)
2292 if (i == ic->nb_streams) {
2293 /* NOTE: if the format has no header, then we need to read
2294 some packets to get most of the streams, so we cannot
2296 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2297 /* if we found the info for all the codecs, we can stop */
2299 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2303 /* we did not get all the codec info, but we read too much data */
2304 if (read_size >= ic->probesize) {
2306 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2310 /* NOTE: a new stream can be added there if no header in file
2311 (AVFMTCTX_NOHEADER) */
2312 ret = av_read_frame_internal(ic, &pkt1);
2313 if (ret < 0 && ret != AVERROR(EAGAIN)) {
2315 ret = -1; /* we could not have all the codec parameters before EOF */
2316 for(i=0;i<ic->nb_streams;i++) {
2317 st = ic->streams[i];
2318 if (!has_codec_parameters(st->codec)){
2320 avcodec_string(buf, sizeof(buf), st->codec, 0);
2321 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2329 if (ret == AVERROR(EAGAIN))
2332 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2333 if ((ret = av_dup_packet(pkt)) < 0)
2334 goto find_stream_info_err;
2336 read_size += pkt->size;
2338 st = ic->streams[pkt->stream_index];
2339 if (st->codec_info_nb_frames>1) {
2340 if (st->time_base.den > 0 && av_rescale_q(st->info->codec_info_duration, st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration) {
2341 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2344 st->info->codec_info_duration += pkt->duration;
2347 int64_t last = st->info->last_dts;
2348 int64_t duration= pkt->dts - last;
2350 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2351 double dur= duration * av_q2d(st->time_base);
2353 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2354 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2355 if (st->info->duration_count < 2)
2356 memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2357 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2358 int framerate= get_std_framerate(i);
2359 int ticks= lrintf(dur*framerate/(1001*12));
2360 double error= dur - ticks*1001*12/(double)framerate;
2361 st->info->duration_error[i] += error*error;
2363 st->info->duration_count++;
2364 // ignore the first 4 values, they might have some random jitter
2365 if (st->info->duration_count > 3)
2366 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2368 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2369 st->info->last_dts = pkt->dts;
2371 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2372 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2374 st->codec->extradata_size= i;
2375 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2376 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2377 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2381 /* if still no information, we try to open the codec and to
2382 decompress the frame. We try to avoid that in most cases as
2383 it takes longer and uses more memory. For MPEG-4, we need to
2384 decompress for QuickTime. */
2385 if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2386 try_decode_frame(st, pkt);
2388 st->codec_info_nb_frames++;
2392 // close codecs which were opened in try_decode_frame()
2393 for(i=0;i<ic->nb_streams;i++) {
2394 st = ic->streams[i];
2395 if(st->codec->codec)
2396 avcodec_close(st->codec);
2398 for(i=0;i<ic->nb_streams;i++) {
2399 st = ic->streams[i];
2400 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2401 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2402 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2403 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2404 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2405 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2406 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2408 // the check for tb_unreliable() is not completely correct, since this is not about handling
2409 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2410 // ipmovie.c produces.
2411 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)
2412 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);
2413 if (st->info->duration_count && !st->r_frame_rate.num
2414 && tb_unreliable(st->codec) /*&&
2415 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2416 st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2418 double best_error= 2*av_q2d(st->time_base);
2419 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2421 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2422 double error = st->info->duration_error[j] * get_std_framerate(j);
2423 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2424 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2425 if(error < best_error){
2427 num = get_std_framerate(j);
2430 // do not increase frame rate by more than 1 % in order to match a standard rate.
2431 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2432 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2435 if (!st->r_frame_rate.num){
2436 if( st->codec->time_base.den * (int64_t)st->time_base.num
2437 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2438 st->r_frame_rate.num = st->codec->time_base.den;
2439 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2441 st->r_frame_rate.num = st->time_base.den;
2442 st->r_frame_rate.den = st->time_base.num;
2445 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2446 if(!st->codec->bits_per_coded_sample)
2447 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2451 av_estimate_timings(ic, old_offset);
2453 compute_chapters_end(ic);
2456 /* correct DTS for B-frame streams with no timestamps */
2457 for(i=0;i<ic->nb_streams;i++) {
2458 st = ic->streams[i];
2459 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2461 ppktl = &ic->packet_buffer;
2463 if(ppkt1->stream_index != i)
2465 if(ppkt1->pkt->dts < 0)
2467 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2469 ppkt1->pkt->dts -= delta;
2474 st->cur_dts -= delta;
2480 find_stream_info_err:
2481 for (i=0; i < ic->nb_streams; i++)
2482 av_freep(&ic->streams[i]->info);
2486 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2490 for (i = 0; i < ic->nb_programs; i++)
2491 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2492 if (ic->programs[i]->stream_index[j] == s)
2493 return ic->programs[i];
2497 int av_find_best_stream(AVFormatContext *ic,
2498 enum AVMediaType type,
2499 int wanted_stream_nb,
2501 AVCodec **decoder_ret,
2504 int i, nb_streams = ic->nb_streams;
2505 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2506 unsigned *program = NULL;
2507 AVCodec *decoder = NULL, *best_decoder = NULL;
2509 if (related_stream >= 0 && wanted_stream_nb < 0) {
2510 AVProgram *p = find_program_from_stream(ic, related_stream);
2512 program = p->stream_index;
2513 nb_streams = p->nb_stream_indexes;
2516 for (i = 0; i < nb_streams; i++) {
2517 int real_stream_index = program ? program[i] : i;
2518 AVStream *st = ic->streams[real_stream_index];
2519 AVCodecContext *avctx = st->codec;
2520 if (avctx->codec_type != type)
2522 if (wanted_stream_nb >= 0 && real_stream_index != wanted_stream_nb)
2524 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2527 decoder = avcodec_find_decoder(st->codec->codec_id);
2530 ret = AVERROR_DECODER_NOT_FOUND;
2534 if (best_count >= st->codec_info_nb_frames)
2536 best_count = st->codec_info_nb_frames;
2537 ret = real_stream_index;
2538 best_decoder = decoder;
2539 if (program && i == nb_streams - 1 && ret < 0) {
2541 nb_streams = ic->nb_streams;
2542 i = 0; /* no related stream found, try again with everything */
2546 *decoder_ret = best_decoder;
2550 /*******************************************************/
2552 int av_read_play(AVFormatContext *s)
2554 if (s->iformat->read_play)
2555 return s->iformat->read_play(s);
2557 return av_url_read_fpause(s->pb, 0);
2558 return AVERROR(ENOSYS);
2561 int av_read_pause(AVFormatContext *s)
2563 if (s->iformat->read_pause)
2564 return s->iformat->read_pause(s);
2566 return av_url_read_fpause(s->pb, 1);
2567 return AVERROR(ENOSYS);
2570 void av_close_input_stream(AVFormatContext *s)
2572 flush_packet_queue(s);
2573 if (s->iformat->read_close)
2574 s->iformat->read_close(s);
2575 avformat_free_context(s);
2578 void avformat_free_context(AVFormatContext *s)
2583 for(i=0;i<s->nb_streams;i++) {
2584 /* free all data in a stream component */
2587 av_parser_close(st->parser);
2588 av_free_packet(&st->cur_pkt);
2590 av_metadata_free(&st->metadata);
2591 av_free(st->index_entries);
2592 av_free(st->codec->extradata);
2593 av_free(st->codec->subtitle_header);
2595 #if FF_API_OLD_METADATA
2596 av_free(st->filename);
2598 av_free(st->priv_data);
2602 for(i=s->nb_programs-1; i>=0; i--) {
2603 #if FF_API_OLD_METADATA
2604 av_freep(&s->programs[i]->provider_name);
2605 av_freep(&s->programs[i]->name);
2607 av_metadata_free(&s->programs[i]->metadata);
2608 av_freep(&s->programs[i]->stream_index);
2609 av_freep(&s->programs[i]);
2611 av_freep(&s->programs);
2612 av_freep(&s->priv_data);
2613 while(s->nb_chapters--) {
2614 #if FF_API_OLD_METADATA
2615 av_free(s->chapters[s->nb_chapters]->title);
2617 av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2618 av_free(s->chapters[s->nb_chapters]);
2620 av_freep(&s->chapters);
2621 av_metadata_free(&s->metadata);
2626 void av_close_input_file(AVFormatContext *s)
2628 AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2629 av_close_input_stream(s);
2634 AVStream *av_new_stream(AVFormatContext *s, int id)
2639 #if FF_API_MAX_STREAMS
2640 if (s->nb_streams >= MAX_STREAMS){
2641 av_log(s, AV_LOG_ERROR, "Too many streams\n");
2647 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2649 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2652 s->streams = streams;
2655 st = av_mallocz(sizeof(AVStream));
2658 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2663 st->codec= avcodec_alloc_context();
2665 /* no default bitrate if decoding */
2666 st->codec->bit_rate = 0;
2668 st->index = s->nb_streams;
2670 st->start_time = AV_NOPTS_VALUE;
2671 st->duration = AV_NOPTS_VALUE;
2672 /* we set the current DTS to 0 so that formats without any timestamps
2673 but durations get some timestamps, formats with some unknown
2674 timestamps have their first few packets buffered and the
2675 timestamps corrected before they are returned to the user */
2677 st->first_dts = AV_NOPTS_VALUE;
2678 st->probe_packets = MAX_PROBE_PACKETS;
2680 /* default pts setting is MPEG-like */
2681 av_set_pts_info(st, 33, 1, 90000);
2682 st->last_IP_pts = AV_NOPTS_VALUE;
2683 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2684 st->pts_buffer[i]= AV_NOPTS_VALUE;
2685 st->reference_dts = AV_NOPTS_VALUE;
2687 st->sample_aspect_ratio = (AVRational){0,1};
2689 s->streams[s->nb_streams++] = st;
2693 AVProgram *av_new_program(AVFormatContext *ac, int id)
2695 AVProgram *program=NULL;
2699 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2702 for(i=0; i<ac->nb_programs; i++)
2703 if(ac->programs[i]->id == id)
2704 program = ac->programs[i];
2707 program = av_mallocz(sizeof(AVProgram));
2710 dynarray_add(&ac->programs, &ac->nb_programs, program);
2711 program->discard = AVDISCARD_NONE;
2718 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2720 AVChapter *chapter = NULL;
2723 for(i=0; i<s->nb_chapters; i++)
2724 if(s->chapters[i]->id == id)
2725 chapter = s->chapters[i];
2728 chapter= av_mallocz(sizeof(AVChapter));
2731 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2733 #if FF_API_OLD_METADATA
2734 av_free(chapter->title);
2736 av_metadata_set2(&chapter->metadata, "title", title, 0);
2738 chapter->time_base= time_base;
2739 chapter->start = start;
2745 /************************************************************/
2746 /* output media file */
2748 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2752 if (s->oformat->priv_data_size > 0) {
2753 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2755 return AVERROR(ENOMEM);
2756 if (s->oformat->priv_class) {
2757 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2758 av_opt_set_defaults(s->priv_data);
2761 s->priv_data = NULL;
2763 if (s->oformat->set_parameters) {
2764 ret = s->oformat->set_parameters(s, ap);
2771 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2773 const AVCodecTag *avctag;
2775 enum CodecID id = CODEC_ID_NONE;
2776 unsigned int tag = 0;
2779 * Check that tag + id is in the table
2780 * If neither is in the table -> OK
2781 * If tag is in the table with another id -> FAIL
2782 * If id is in the table with another tag -> FAIL unless strict < normal
2784 for (n = 0; s->oformat->codec_tag[n]; n++) {
2785 avctag = s->oformat->codec_tag[n];
2786 while (avctag->id != CODEC_ID_NONE) {
2787 if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2789 if (id == st->codec->codec_id)
2792 if (avctag->id == st->codec->codec_id)
2797 if (id != CODEC_ID_NONE)
2799 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2804 int av_write_header(AVFormatContext *s)
2809 // some sanity checks
2810 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2811 av_log(s, AV_LOG_ERROR, "no streams\n");
2812 return AVERROR(EINVAL);
2815 for(i=0;i<s->nb_streams;i++) {
2818 switch (st->codec->codec_type) {
2819 case AVMEDIA_TYPE_AUDIO:
2820 if(st->codec->sample_rate<=0){
2821 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2822 return AVERROR(EINVAL);
2824 if(!st->codec->block_align)
2825 st->codec->block_align = st->codec->channels *
2826 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2828 case AVMEDIA_TYPE_VIDEO:
2829 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2830 av_log(s, AV_LOG_ERROR, "time base not set\n");
2831 return AVERROR(EINVAL);
2833 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2834 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2835 return AVERROR(EINVAL);
2837 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2838 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2839 return AVERROR(EINVAL);
2844 if(s->oformat->codec_tag){
2845 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)){
2846 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2847 st->codec->codec_tag= 0;
2849 if(st->codec->codec_tag){
2850 if (!validate_codec_tag(s, st)) {
2852 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2853 av_log(s, AV_LOG_ERROR,
2854 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2855 tagbuf, st->codec->codec_tag, st->codec->codec_id);
2856 return AVERROR_INVALIDDATA;
2859 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2862 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2863 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2864 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2867 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2868 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2870 return AVERROR(ENOMEM);
2873 #if FF_API_OLD_METADATA
2874 ff_metadata_mux_compat(s);
2877 /* set muxer identification string */
2878 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2879 av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2882 if(s->oformat->write_header){
2883 ret = s->oformat->write_header(s);
2888 /* init PTS generation */
2889 for(i=0;i<s->nb_streams;i++) {
2890 int64_t den = AV_NOPTS_VALUE;
2893 switch (st->codec->codec_type) {
2894 case AVMEDIA_TYPE_AUDIO:
2895 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2897 case AVMEDIA_TYPE_VIDEO:
2898 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2903 if (den != AV_NOPTS_VALUE) {
2905 return AVERROR_INVALIDDATA;
2906 av_frac_init(&st->pts, 0, 0, den);
2912 //FIXME merge with compute_pkt_fields
2913 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2914 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2915 int num, den, frame_size, i;
2917 av_dlog(s, "compute_pkt_fields2: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2918 pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2920 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2923 /* duration field */
2924 if (pkt->duration == 0) {
2925 compute_frame_duration(&num, &den, st, NULL, pkt);
2927 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2931 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2934 //XXX/FIXME this is a temporary hack until all encoders output pts
2935 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2937 // pkt->pts= st->cur_dts;
2938 pkt->pts= st->pts.val;
2941 //calculate dts from pts
2942 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2943 st->pts_buffer[0]= pkt->pts;
2944 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2945 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2946 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2947 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2949 pkt->dts= st->pts_buffer[0];
2952 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2953 av_log(s, AV_LOG_ERROR,
2954 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2955 st->index, st->cur_dts, pkt->dts);
2958 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2959 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2963 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2964 st->cur_dts= pkt->dts;
2965 st->pts.val= pkt->dts;
2968 switch (st->codec->codec_type) {
2969 case AVMEDIA_TYPE_AUDIO:
2970 frame_size = get_audio_frame_size(st->codec, pkt->size);
2972 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2973 likely equal to the encoder delay, but it would be better if we
2974 had the real timestamps from the encoder */
2975 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2976 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2979 case AVMEDIA_TYPE_VIDEO:
2980 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2988 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2990 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2992 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2995 ret= s->oformat->write_packet(s, pkt);
2997 ret= url_ferror(s->pb);
3001 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3002 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3004 AVPacketList **next_point, *this_pktl;
3006 this_pktl = av_mallocz(sizeof(AVPacketList));
3007 this_pktl->pkt= *pkt;
3008 pkt->destruct= NULL; // do not free original but only the copy
3009 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
3011 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3012 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3014 next_point = &s->packet_buffer;
3017 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3018 while(!compare(s, &(*next_point)->pkt, pkt)){
3019 next_point= &(*next_point)->next;
3023 next_point = &(s->packet_buffer_end->next);
3026 assert(!*next_point);
3028 s->packet_buffer_end= this_pktl;
3031 this_pktl->next= *next_point;
3033 s->streams[pkt->stream_index]->last_in_packet_buffer=
3034 *next_point= this_pktl;
3037 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3039 AVStream *st = s->streams[ pkt ->stream_index];
3040 AVStream *st2= s->streams[ next->stream_index];
3041 int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3042 int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3043 return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
3046 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3052 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3055 for(i=0; i < s->nb_streams; i++)
3056 stream_count+= !!s->streams[i]->last_in_packet_buffer;
3058 if(stream_count && (s->nb_streams == stream_count || flush)){
3059 pktl= s->packet_buffer;
3062 s->packet_buffer= pktl->next;
3063 if(!s->packet_buffer)
3064 s->packet_buffer_end= NULL;
3066 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3067 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3071 av_init_packet(out);
3077 * Interleave an AVPacket correctly so it can be muxed.
3078 * @param out the interleaved packet will be output here
3079 * @param in the input packet
3080 * @param flush 1 if no further packets are available as input and all
3081 * remaining packets should be output
3082 * @return 1 if a packet was output, 0 if no packet could be output,
3083 * < 0 if an error occurred
3085 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3086 if(s->oformat->interleave_packet)
3087 return s->oformat->interleave_packet(s, out, in, flush);
3089 return av_interleave_packet_per_dts(s, out, in, flush);
3092 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3093 AVStream *st= s->streams[ pkt->stream_index];
3096 //FIXME/XXX/HACK drop zero sized packets
3097 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3100 av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3101 pkt->size, pkt->dts, pkt->pts);
3102 if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3105 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3106 return AVERROR(EINVAL);
3110 int ret= av_interleave_packet(s, &opkt, pkt, 0);
3111 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3114 ret= s->oformat->write_packet(s, &opkt);
3116 av_free_packet(&opkt);
3121 if(url_ferror(s->pb))
3122 return url_ferror(s->pb);
3126 int av_write_trailer(AVFormatContext *s)
3132 ret= av_interleave_packet(s, &pkt, NULL, 1);
3133 if(ret<0) //FIXME cleanup needed for ret<0 ?
3138 ret= s->oformat->write_packet(s, &pkt);
3140 av_free_packet(&pkt);
3144 if(url_ferror(s->pb))
3148 if(s->oformat->write_trailer)
3149 ret = s->oformat->write_trailer(s);
3152 ret=url_ferror(s->pb);
3153 for(i=0;i<s->nb_streams;i++) {
3154 av_freep(&s->streams[i]->priv_data);
3155 av_freep(&s->streams[i]->index_entries);
3157 av_freep(&s->priv_data);
3161 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3164 AVProgram *program=NULL;
3167 if (idx >= ac->nb_streams) {
3168 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3172 for(i=0; i<ac->nb_programs; i++){
3173 if(ac->programs[i]->id != progid)
3175 program = ac->programs[i];
3176 for(j=0; j<program->nb_stream_indexes; j++)
3177 if(program->stream_index[j] == idx)
3180 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3183 program->stream_index = tmp;
3184 program->stream_index[program->nb_stream_indexes++] = idx;
3189 static void print_fps(double d, const char *postfix){
3190 uint64_t v= lrintf(d*100);
3191 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3192 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3193 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3196 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3198 if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3199 AVMetadataTag *tag=NULL;
3201 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3202 while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3203 if(strcmp("language", tag->key))
3204 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
3209 /* "user interface" functions */
3210 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3213 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3214 AVStream *st = ic->streams[i];
3215 int g = av_gcd(st->time_base.num, st->time_base.den);
3216 AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3217 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3218 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
3219 /* the pid is an important information, so we display it */
3220 /* XXX: add a generic system */
3221 if (flags & AVFMT_SHOW_IDS)
3222 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3224 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3225 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3226 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3227 if (st->sample_aspect_ratio.num && // default
3228 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3229 AVRational display_aspect_ratio;
3230 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3231 st->codec->width*st->sample_aspect_ratio.num,
3232 st->codec->height*st->sample_aspect_ratio.den,
3234 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3235 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3236 display_aspect_ratio.num, display_aspect_ratio.den);
3238 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3239 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3240 print_fps(av_q2d(st->avg_frame_rate), "fps");
3241 if(st->r_frame_rate.den && st->r_frame_rate.num)
3242 print_fps(av_q2d(st->r_frame_rate), "tbr");
3243 if(st->time_base.den && st->time_base.num)
3244 print_fps(1/av_q2d(st->time_base), "tbn");
3245 if(st->codec->time_base.den && st->codec->time_base.num)
3246 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3248 if (st->disposition & AV_DISPOSITION_DEFAULT)
3249 av_log(NULL, AV_LOG_INFO, " (default)");
3250 if (st->disposition & AV_DISPOSITION_DUB)
3251 av_log(NULL, AV_LOG_INFO, " (dub)");
3252 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3253 av_log(NULL, AV_LOG_INFO, " (original)");
3254 if (st->disposition & AV_DISPOSITION_COMMENT)
3255 av_log(NULL, AV_LOG_INFO, " (comment)");
3256 if (st->disposition & AV_DISPOSITION_LYRICS)
3257 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3258 if (st->disposition & AV_DISPOSITION_KARAOKE)
3259 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3260 if (st->disposition & AV_DISPOSITION_FORCED)
3261 av_log(NULL, AV_LOG_INFO, " (forced)");
3262 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3263 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3264 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3265 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3266 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3267 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3268 av_log(NULL, AV_LOG_INFO, "\n");
3269 dump_metadata(NULL, st->metadata, " ");
3272 #if FF_API_DUMP_FORMAT
3273 void dump_format(AVFormatContext *ic,
3278 av_dump_format(ic, index, url, is_output);
3282 void av_dump_format(AVFormatContext *ic,
3288 uint8_t *printed = av_mallocz(ic->nb_streams);
3289 if (ic->nb_streams && !printed)
3292 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3293 is_output ? "Output" : "Input",
3295 is_output ? ic->oformat->name : ic->iformat->name,
3296 is_output ? "to" : "from", url);
3297 dump_metadata(NULL, ic->metadata, " ");
3299 av_log(NULL, AV_LOG_INFO, " Duration: ");
3300 if (ic->duration != AV_NOPTS_VALUE) {
3301 int hours, mins, secs, us;
3302 secs = ic->duration / AV_TIME_BASE;
3303 us = ic->duration % AV_TIME_BASE;
3308 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3309 (100 * us) / AV_TIME_BASE);
3311 av_log(NULL, AV_LOG_INFO, "N/A");
3313 if (ic->start_time != AV_NOPTS_VALUE) {
3315 av_log(NULL, AV_LOG_INFO, ", start: ");
3316 secs = ic->start_time / AV_TIME_BASE;
3317 us = abs(ic->start_time % AV_TIME_BASE);
3318 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3319 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3321 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3323 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3325 av_log(NULL, AV_LOG_INFO, "N/A");
3327 av_log(NULL, AV_LOG_INFO, "\n");
3329 for (i = 0; i < ic->nb_chapters; i++) {
3330 AVChapter *ch = ic->chapters[i];
3331 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3332 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3333 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3335 dump_metadata(NULL, ch->metadata, " ");
3337 if(ic->nb_programs) {
3338 int j, k, total = 0;
3339 for(j=0; j<ic->nb_programs; j++) {
3340 AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3342 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3343 name ? name->value : "");
3344 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3345 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3346 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3347 printed[ic->programs[j]->stream_index[k]] = 1;
3349 total += ic->programs[j]->nb_stream_indexes;
3351 if (total < ic->nb_streams)
3352 av_log(NULL, AV_LOG_INFO, " No Program\n");
3354 for(i=0;i<ic->nb_streams;i++)
3356 dump_stream_format(ic, i, index, is_output);
3361 #if FF_API_PARSE_FRAME_PARAM
3362 #include "libavutil/parseutils.h"
3364 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3366 return av_parse_video_size(width_ptr, height_ptr, str);
3369 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3371 AVRational frame_rate;
3372 int ret = av_parse_video_rate(&frame_rate, arg);
3373 *frame_rate_num= frame_rate.num;
3374 *frame_rate_den= frame_rate.den;
3379 int64_t av_gettime(void)
3382 gettimeofday(&tv,NULL);
3383 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3386 uint64_t ff_ntp_time(void)
3388 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3391 #if FF_API_PARSE_DATE
3392 #include "libavutil/parseutils.h"
3394 int64_t parse_date(const char *timestr, int duration)
3397 av_parse_time(&timeval, timestr, duration);
3402 #if FF_API_FIND_INFO_TAG
3403 #include "libavutil/parseutils.h"
3405 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3407 return av_find_info_tag(arg, arg_size, tag1, info);
3411 int av_get_frame_filename(char *buf, int buf_size,
3412 const char *path, int number)
3415 char *q, buf1[20], c;
3416 int nd, len, percentd_found;
3428 while (isdigit(*p)) {
3429 nd = nd * 10 + *p++ - '0';
3432 } while (isdigit(c));
3441 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3443 if ((q - buf + len) > buf_size - 1)
3445 memcpy(q, buf1, len);
3453 if ((q - buf) < buf_size - 1)
3457 if (!percentd_found)
3466 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3470 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3472 for(i=0;i<size;i+=16) {
3479 PRINT(" %02x", buf[i+j]);
3484 for(j=0;j<len;j++) {
3486 if (c < ' ' || c > '~')
3495 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3497 hex_dump_internal(NULL, f, 0, buf, size);
3500 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3502 hex_dump_internal(avcl, NULL, level, buf, size);
3505 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3508 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3509 PRINT("stream #%d:\n", pkt->stream_index);
3510 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3511 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3512 /* DTS is _always_ valid after av_read_frame() */
3514 if (pkt->dts == AV_NOPTS_VALUE)
3517 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3518 /* PTS may not be known if B-frames are present. */
3520 if (pkt->pts == AV_NOPTS_VALUE)
3523 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3525 PRINT(" size=%d\n", pkt->size);
3528 av_hex_dump(f, pkt->data, pkt->size);
3531 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3533 AVRational tb = { 1, AV_TIME_BASE };
3534 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3537 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3539 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3542 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3544 AVRational tb = { 1, AV_TIME_BASE };
3545 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3548 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3551 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3554 #if FF_API_URL_SPLIT
3555 attribute_deprecated
3556 void ff_url_split(char *proto, int proto_size,
3557 char *authorization, int authorization_size,
3558 char *hostname, int hostname_size,
3560 char *path, int path_size,
3563 av_url_split(proto, proto_size,
3564 authorization, authorization_size,
3565 hostname, hostname_size,
3572 void av_url_split(char *proto, int proto_size,
3573 char *authorization, int authorization_size,
3574 char *hostname, int hostname_size,
3576 char *path, int path_size,
3579 const char *p, *ls, *at, *col, *brk;
3581 if (port_ptr) *port_ptr = -1;
3582 if (proto_size > 0) proto[0] = 0;
3583 if (authorization_size > 0) authorization[0] = 0;
3584 if (hostname_size > 0) hostname[0] = 0;
3585 if (path_size > 0) path[0] = 0;
3587 /* parse protocol */
3588 if ((p = strchr(url, ':'))) {
3589 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3594 /* no protocol means plain filename */
3595 av_strlcpy(path, url, path_size);
3599 /* separate path from hostname */
3600 ls = strchr(p, '/');
3602 ls = strchr(p, '?');
3604 av_strlcpy(path, ls, path_size);
3606 ls = &p[strlen(p)]; // XXX
3608 /* the rest is hostname, use that to parse auth/port */
3610 /* authorization (user[:pass]@hostname) */
3611 if ((at = strchr(p, '@')) && at < ls) {
3612 av_strlcpy(authorization, p,
3613 FFMIN(authorization_size, at + 1 - p));
3614 p = at + 1; /* skip '@' */
3617 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3619 av_strlcpy(hostname, p + 1,
3620 FFMIN(hostname_size, brk - p));
3621 if (brk[1] == ':' && port_ptr)
3622 *port_ptr = atoi(brk + 2);
3623 } else if ((col = strchr(p, ':')) && col < ls) {
3624 av_strlcpy(hostname, p,
3625 FFMIN(col + 1 - p, hostname_size));
3626 if (port_ptr) *port_ptr = atoi(col + 1);
3628 av_strlcpy(hostname, p,
3629 FFMIN(ls + 1 - p, hostname_size));
3633 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3636 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3639 'C', 'D', 'E', 'F' };
3640 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3643 'c', 'd', 'e', 'f' };
3644 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3646 for(i = 0; i < s; i++) {
3647 buff[i * 2] = hex_table[src[i] >> 4];
3648 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3654 int ff_hex_to_data(uint8_t *data, const char *p)
3661 p += strspn(p, SPACE_CHARS);
3664 c = toupper((unsigned char) *p++);
3665 if (c >= '0' && c <= '9')
3667 else if (c >= 'A' && c <= 'F')
3682 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3683 unsigned int pts_num, unsigned int pts_den)
3686 if(av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)){
3687 if(new_tb.num != pts_num)
3688 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/new_tb.num);
3690 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3692 if(new_tb.num <= 0 || new_tb.den <= 0) {
3693 av_log(NULL, AV_LOG_ERROR, "Ignoring attempt to set invalid timebase for st:%d\n", s->index);
3696 s->time_base = new_tb;
3697 s->pts_wrap_bits = pts_wrap_bits;
3700 int ff_url_join(char *str, int size, const char *proto,
3701 const char *authorization, const char *hostname,
3702 int port, const char *fmt, ...)
3705 struct addrinfo hints, *ai;
3710 av_strlcatf(str, size, "%s://", proto);
3711 if (authorization && authorization[0])
3712 av_strlcatf(str, size, "%s@", authorization);
3713 #if CONFIG_NETWORK && defined(AF_INET6)
3714 /* Determine if hostname is a numerical IPv6 address,
3715 * properly escape it within [] in that case. */
3716 memset(&hints, 0, sizeof(hints));
3717 hints.ai_flags = AI_NUMERICHOST;
3718 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3719 if (ai->ai_family == AF_INET6) {
3720 av_strlcat(str, "[", size);
3721 av_strlcat(str, hostname, size);
3722 av_strlcat(str, "]", size);
3724 av_strlcat(str, hostname, size);
3729 /* Not an IPv6 address, just output the plain string. */
3730 av_strlcat(str, hostname, size);
3733 av_strlcatf(str, size, ":%d", port);
3736 int len = strlen(str);
3739 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3745 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3746 AVFormatContext *src)
3751 local_pkt.stream_index = dst_stream;
3752 if (pkt->pts != AV_NOPTS_VALUE)
3753 local_pkt.pts = av_rescale_q(pkt->pts,
3754 src->streams[pkt->stream_index]->time_base,
3755 dst->streams[dst_stream]->time_base);
3756 if (pkt->dts != AV_NOPTS_VALUE)
3757 local_pkt.dts = av_rescale_q(pkt->dts,
3758 src->streams[pkt->stream_index]->time_base,
3759 dst->streams[dst_stream]->time_base);
3760 return av_write_frame(dst, &local_pkt);
3763 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3766 const char *ptr = str;
3768 /* Parse key=value pairs. */
3771 char *dest = NULL, *dest_end;
3772 int key_len, dest_len = 0;
3774 /* Skip whitespace and potential commas. */
3775 while (*ptr && (isspace(*ptr) || *ptr == ','))
3782 if (!(ptr = strchr(key, '=')))
3785 key_len = ptr - key;
3787 callback_get_buf(context, key, key_len, &dest, &dest_len);
3788 dest_end = dest + dest_len - 1;
3792 while (*ptr && *ptr != '\"') {
3796 if (dest && dest < dest_end)
3800 if (dest && dest < dest_end)
3808 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3809 if (dest && dest < dest_end)
3817 int ff_find_stream_index(AVFormatContext *s, int id)
3820 for (i = 0; i < s->nb_streams; i++) {
3821 if (s->streams[i]->id == id)
3827 void ff_make_absolute_url(char *buf, int size, const char *base,
3831 /* Absolute path, relative to the current server */
3832 if (base && strstr(base, "://") && rel[0] == '/') {
3834 av_strlcpy(buf, base, size);
3835 sep = strstr(buf, "://");
3838 sep = strchr(sep, '/');
3842 av_strlcat(buf, rel, size);
3845 /* If rel actually is an absolute url, just copy it */
3846 if (!base || strstr(rel, "://") || rel[0] == '/') {
3847 av_strlcpy(buf, rel, size);
3851 av_strlcpy(buf, base, size);
3852 /* Remove the file name from the base url */
3853 sep = strrchr(buf, '/');
3858 while (av_strstart(rel, "../", NULL) && sep) {
3859 /* Remove the path delimiter at the end */
3861 sep = strrchr(buf, '/');
3862 /* If the next directory name to pop off is "..", break here */
3863 if (!strcmp(sep ? &sep[1] : buf, "..")) {
3864 /* Readd the slash we just removed */
3865 av_strlcat(buf, "/", size);
3868 /* Cut off the directory name */
3875 av_strlcat(buf, rel, size);