2 * various utility functions for use within Libav
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; 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 Libav
50 unsigned avformat_version(void)
52 return LIBAVFORMAT_VERSION_INT;
55 const char *avformat_configuration(void)
57 return LIBAV_CONFIGURATION;
60 const char *avformat_license(void)
62 #define LICENSE_PREFIX "libavformat license: "
63 return LICENSE_PREFIX LIBAV_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 > 1 && !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);
2448 // set stream disposition based on audio service type
2449 switch (st->codec->audio_service_type) {
2450 case AV_AUDIO_SERVICE_TYPE_EFFECTS:
2451 st->disposition = AV_DISPOSITION_CLEAN_EFFECTS; break;
2452 case AV_AUDIO_SERVICE_TYPE_VISUALLY_IMPAIRED:
2453 st->disposition = AV_DISPOSITION_VISUAL_IMPAIRED; break;
2454 case AV_AUDIO_SERVICE_TYPE_HEARING_IMPAIRED:
2455 st->disposition = AV_DISPOSITION_HEARING_IMPAIRED; break;
2456 case AV_AUDIO_SERVICE_TYPE_COMMENTARY:
2457 st->disposition = AV_DISPOSITION_COMMENT; break;
2458 case AV_AUDIO_SERVICE_TYPE_KARAOKE:
2459 st->disposition = AV_DISPOSITION_KARAOKE; break;
2464 av_estimate_timings(ic, old_offset);
2466 compute_chapters_end(ic);
2469 /* correct DTS for B-frame streams with no timestamps */
2470 for(i=0;i<ic->nb_streams;i++) {
2471 st = ic->streams[i];
2472 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2474 ppktl = &ic->packet_buffer;
2476 if(ppkt1->stream_index != i)
2478 if(ppkt1->pkt->dts < 0)
2480 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2482 ppkt1->pkt->dts -= delta;
2487 st->cur_dts -= delta;
2493 find_stream_info_err:
2494 for (i=0; i < ic->nb_streams; i++)
2495 av_freep(&ic->streams[i]->info);
2499 static AVProgram *find_program_from_stream(AVFormatContext *ic, int s)
2503 for (i = 0; i < ic->nb_programs; i++)
2504 for (j = 0; j < ic->programs[i]->nb_stream_indexes; j++)
2505 if (ic->programs[i]->stream_index[j] == s)
2506 return ic->programs[i];
2510 int av_find_best_stream(AVFormatContext *ic,
2511 enum AVMediaType type,
2512 int wanted_stream_nb,
2514 AVCodec **decoder_ret,
2517 int i, nb_streams = ic->nb_streams, stream_number = 0;
2518 int ret = AVERROR_STREAM_NOT_FOUND, best_count = -1;
2519 unsigned *program = NULL;
2520 AVCodec *decoder = NULL, *best_decoder = NULL;
2522 if (related_stream >= 0 && wanted_stream_nb < 0) {
2523 AVProgram *p = find_program_from_stream(ic, related_stream);
2525 program = p->stream_index;
2526 nb_streams = p->nb_stream_indexes;
2529 for (i = 0; i < nb_streams; i++) {
2530 AVStream *st = ic->streams[program ? program[i] : i];
2531 AVCodecContext *avctx = st->codec;
2532 if (avctx->codec_type != type)
2534 if (wanted_stream_nb >= 0 && stream_number++ != wanted_stream_nb)
2536 if (st->disposition & (AV_DISPOSITION_HEARING_IMPAIRED|AV_DISPOSITION_VISUAL_IMPAIRED))
2539 decoder = avcodec_find_decoder(ic->streams[i]->codec->codec_id);
2542 ret = AVERROR_DECODER_NOT_FOUND;
2546 if (best_count >= st->codec_info_nb_frames)
2548 best_count = st->codec_info_nb_frames;
2549 ret = program ? program[i] : i;
2550 best_decoder = decoder;
2551 if (program && i == nb_streams - 1 && ret < 0) {
2553 nb_streams = ic->nb_streams;
2554 i = 0; /* no related stream found, try again with everything */
2558 *decoder_ret = best_decoder;
2562 /*******************************************************/
2564 int av_read_play(AVFormatContext *s)
2566 if (s->iformat->read_play)
2567 return s->iformat->read_play(s);
2569 return ffio_read_pause(s->pb, 0);
2570 return AVERROR(ENOSYS);
2573 int av_read_pause(AVFormatContext *s)
2575 if (s->iformat->read_pause)
2576 return s->iformat->read_pause(s);
2578 return ffio_read_pause(s->pb, 1);
2579 return AVERROR(ENOSYS);
2582 void av_close_input_stream(AVFormatContext *s)
2584 flush_packet_queue(s);
2585 if (s->iformat->read_close)
2586 s->iformat->read_close(s);
2587 avformat_free_context(s);
2590 void avformat_free_context(AVFormatContext *s)
2595 for(i=0;i<s->nb_streams;i++) {
2596 /* free all data in a stream component */
2599 av_parser_close(st->parser);
2600 av_free_packet(&st->cur_pkt);
2602 av_metadata_free(&st->metadata);
2603 av_free(st->index_entries);
2604 av_free(st->codec->extradata);
2605 av_free(st->codec->subtitle_header);
2607 #if FF_API_OLD_METADATA
2608 av_free(st->filename);
2610 av_free(st->priv_data);
2614 for(i=s->nb_programs-1; i>=0; i--) {
2615 #if FF_API_OLD_METADATA
2616 av_freep(&s->programs[i]->provider_name);
2617 av_freep(&s->programs[i]->name);
2619 av_metadata_free(&s->programs[i]->metadata);
2620 av_freep(&s->programs[i]->stream_index);
2621 av_freep(&s->programs[i]);
2623 av_freep(&s->programs);
2624 av_freep(&s->priv_data);
2625 while(s->nb_chapters--) {
2626 #if FF_API_OLD_METADATA
2627 av_free(s->chapters[s->nb_chapters]->title);
2629 av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2630 av_free(s->chapters[s->nb_chapters]);
2632 av_freep(&s->chapters);
2633 av_metadata_free(&s->metadata);
2638 void av_close_input_file(AVFormatContext *s)
2640 AVIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2641 av_close_input_stream(s);
2646 AVStream *av_new_stream(AVFormatContext *s, int id)
2651 #if FF_API_MAX_STREAMS
2652 if (s->nb_streams >= MAX_STREAMS){
2653 av_log(s, AV_LOG_ERROR, "Too many streams\n");
2659 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2661 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2664 s->streams = streams;
2667 st = av_mallocz(sizeof(AVStream));
2670 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2675 st->codec= avcodec_alloc_context();
2677 /* no default bitrate if decoding */
2678 st->codec->bit_rate = 0;
2680 st->index = s->nb_streams;
2682 st->start_time = AV_NOPTS_VALUE;
2683 st->duration = AV_NOPTS_VALUE;
2684 /* we set the current DTS to 0 so that formats without any timestamps
2685 but durations get some timestamps, formats with some unknown
2686 timestamps have their first few packets buffered and the
2687 timestamps corrected before they are returned to the user */
2689 st->first_dts = AV_NOPTS_VALUE;
2690 st->probe_packets = MAX_PROBE_PACKETS;
2692 /* default pts setting is MPEG-like */
2693 av_set_pts_info(st, 33, 1, 90000);
2694 st->last_IP_pts = AV_NOPTS_VALUE;
2695 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2696 st->pts_buffer[i]= AV_NOPTS_VALUE;
2697 st->reference_dts = AV_NOPTS_VALUE;
2699 st->sample_aspect_ratio = (AVRational){0,1};
2701 s->streams[s->nb_streams++] = st;
2705 AVProgram *av_new_program(AVFormatContext *ac, int id)
2707 AVProgram *program=NULL;
2711 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2714 for(i=0; i<ac->nb_programs; i++)
2715 if(ac->programs[i]->id == id)
2716 program = ac->programs[i];
2719 program = av_mallocz(sizeof(AVProgram));
2722 dynarray_add(&ac->programs, &ac->nb_programs, program);
2723 program->discard = AVDISCARD_NONE;
2730 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2732 AVChapter *chapter = NULL;
2735 for(i=0; i<s->nb_chapters; i++)
2736 if(s->chapters[i]->id == id)
2737 chapter = s->chapters[i];
2740 chapter= av_mallocz(sizeof(AVChapter));
2743 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2745 #if FF_API_OLD_METADATA
2746 av_free(chapter->title);
2748 av_metadata_set2(&chapter->metadata, "title", title, 0);
2750 chapter->time_base= time_base;
2751 chapter->start = start;
2757 /************************************************************/
2758 /* output media file */
2760 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2764 if (s->oformat->priv_data_size > 0) {
2765 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2767 return AVERROR(ENOMEM);
2768 if (s->oformat->priv_class) {
2769 *(const AVClass**)s->priv_data= s->oformat->priv_class;
2770 av_opt_set_defaults(s->priv_data);
2773 s->priv_data = NULL;
2775 if (s->oformat->set_parameters) {
2776 ret = s->oformat->set_parameters(s, ap);
2783 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2785 const AVCodecTag *avctag;
2787 enum CodecID id = CODEC_ID_NONE;
2788 unsigned int tag = 0;
2791 * Check that tag + id is in the table
2792 * If neither is in the table -> OK
2793 * If tag is in the table with another id -> FAIL
2794 * If id is in the table with another tag -> FAIL unless strict < normal
2796 for (n = 0; s->oformat->codec_tag[n]; n++) {
2797 avctag = s->oformat->codec_tag[n];
2798 while (avctag->id != CODEC_ID_NONE) {
2799 if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2801 if (id == st->codec->codec_id)
2804 if (avctag->id == st->codec->codec_id)
2809 if (id != CODEC_ID_NONE)
2811 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2816 int av_write_header(AVFormatContext *s)
2821 // some sanity checks
2822 if (s->nb_streams == 0 && !(s->oformat->flags & AVFMT_NOSTREAMS)) {
2823 av_log(s, AV_LOG_ERROR, "no streams\n");
2824 return AVERROR(EINVAL);
2827 for(i=0;i<s->nb_streams;i++) {
2830 switch (st->codec->codec_type) {
2831 case AVMEDIA_TYPE_AUDIO:
2832 if(st->codec->sample_rate<=0){
2833 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2834 return AVERROR(EINVAL);
2836 if(!st->codec->block_align)
2837 st->codec->block_align = st->codec->channels *
2838 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2840 case AVMEDIA_TYPE_VIDEO:
2841 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2842 av_log(s, AV_LOG_ERROR, "time base not set\n");
2843 return AVERROR(EINVAL);
2845 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2846 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2847 return AVERROR(EINVAL);
2849 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2850 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2851 return AVERROR(EINVAL);
2856 if(s->oformat->codec_tag){
2857 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)){
2858 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2859 st->codec->codec_tag= 0;
2861 if(st->codec->codec_tag){
2862 if (!validate_codec_tag(s, st)) {
2864 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2865 av_log(s, AV_LOG_ERROR,
2866 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2867 tagbuf, st->codec->codec_tag, st->codec->codec_id);
2868 return AVERROR_INVALIDDATA;
2871 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2874 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2875 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2876 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2879 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2880 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2882 return AVERROR(ENOMEM);
2885 #if FF_API_OLD_METADATA
2886 ff_metadata_mux_compat(s);
2889 /* set muxer identification string */
2890 if (s->nb_streams && !(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2891 av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2894 if(s->oformat->write_header){
2895 ret = s->oformat->write_header(s);
2900 /* init PTS generation */
2901 for(i=0;i<s->nb_streams;i++) {
2902 int64_t den = AV_NOPTS_VALUE;
2905 switch (st->codec->codec_type) {
2906 case AVMEDIA_TYPE_AUDIO:
2907 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2909 case AVMEDIA_TYPE_VIDEO:
2910 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2915 if (den != AV_NOPTS_VALUE) {
2917 return AVERROR_INVALIDDATA;
2918 av_frac_init(&st->pts, 0, 0, den);
2924 //FIXME merge with compute_pkt_fields
2925 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2926 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2927 int num, den, frame_size, i;
2929 av_dlog(s, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n",
2930 pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2932 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2935 /* duration field */
2936 if (pkt->duration == 0) {
2937 compute_frame_duration(&num, &den, st, NULL, pkt);
2939 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2943 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2946 //XXX/FIXME this is a temporary hack until all encoders output pts
2947 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2949 // pkt->pts= st->cur_dts;
2950 pkt->pts= st->pts.val;
2953 //calculate dts from pts
2954 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2955 st->pts_buffer[0]= pkt->pts;
2956 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2957 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2958 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2959 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2961 pkt->dts= st->pts_buffer[0];
2964 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2965 av_log(s, AV_LOG_ERROR,
2966 "Application provided invalid, non monotonically increasing dts to muxer in stream %d: %"PRId64" >= %"PRId64"\n",
2967 st->index, st->cur_dts, pkt->dts);
2970 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2971 av_log(s, AV_LOG_ERROR, "pts < dts in stream %d\n", st->index);
2975 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2976 st->cur_dts= pkt->dts;
2977 st->pts.val= pkt->dts;
2980 switch (st->codec->codec_type) {
2981 case AVMEDIA_TYPE_AUDIO:
2982 frame_size = get_audio_frame_size(st->codec, pkt->size);
2984 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2985 likely equal to the encoder delay, but it would be better if we
2986 had the real timestamps from the encoder */
2987 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2988 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2991 case AVMEDIA_TYPE_VIDEO:
2992 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
3000 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
3002 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
3004 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3007 ret= s->oformat->write_packet(s, pkt);
3011 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
3012 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
3014 AVPacketList **next_point, *this_pktl;
3016 this_pktl = av_mallocz(sizeof(AVPacketList));
3017 this_pktl->pkt= *pkt;
3018 pkt->destruct= NULL; // do not free original but only the copy
3019 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
3021 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
3022 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
3024 next_point = &s->packet_buffer;
3027 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
3028 while(!compare(s, &(*next_point)->pkt, pkt)){
3029 next_point= &(*next_point)->next;
3033 next_point = &(s->packet_buffer_end->next);
3036 assert(!*next_point);
3038 s->packet_buffer_end= this_pktl;
3041 this_pktl->next= *next_point;
3043 s->streams[pkt->stream_index]->last_in_packet_buffer=
3044 *next_point= this_pktl;
3047 static int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
3049 AVStream *st = s->streams[ pkt ->stream_index];
3050 AVStream *st2= s->streams[ next->stream_index];
3051 int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
3052 int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
3053 return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
3056 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
3062 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
3065 for(i=0; i < s->nb_streams; i++)
3066 stream_count+= !!s->streams[i]->last_in_packet_buffer;
3068 if(stream_count && (s->nb_streams == stream_count || flush)){
3069 pktl= s->packet_buffer;
3072 s->packet_buffer= pktl->next;
3073 if(!s->packet_buffer)
3074 s->packet_buffer_end= NULL;
3076 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
3077 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
3081 av_init_packet(out);
3087 * Interleave an AVPacket correctly so it can be muxed.
3088 * @param out the interleaved packet will be output here
3089 * @param in the input packet
3090 * @param flush 1 if no further packets are available as input and all
3091 * remaining packets should be output
3092 * @return 1 if a packet was output, 0 if no packet could be output,
3093 * < 0 if an error occurred
3095 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
3096 if(s->oformat->interleave_packet)
3097 return s->oformat->interleave_packet(s, out, in, flush);
3099 return av_interleave_packet_per_dts(s, out, in, flush);
3102 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
3103 AVStream *st= s->streams[ pkt->stream_index];
3106 //FIXME/XXX/HACK drop zero sized packets
3107 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
3110 av_dlog(s, "av_interleaved_write_frame size:%d dts:%"PRId64" pts:%"PRId64"\n",
3111 pkt->size, pkt->dts, pkt->pts);
3112 if((ret = compute_pkt_fields2(s, st, pkt)) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3115 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3116 return AVERROR(EINVAL);
3120 int ret= av_interleave_packet(s, &opkt, pkt, 0);
3121 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3124 ret= s->oformat->write_packet(s, &opkt);
3126 av_free_packet(&opkt);
3134 int av_write_trailer(AVFormatContext *s)
3140 ret= av_interleave_packet(s, &pkt, NULL, 1);
3141 if(ret<0) //FIXME cleanup needed for ret<0 ?
3146 ret= s->oformat->write_packet(s, &pkt);
3148 av_free_packet(&pkt);
3154 if(s->oformat->write_trailer)
3155 ret = s->oformat->write_trailer(s);
3157 for(i=0;i<s->nb_streams;i++) {
3158 av_freep(&s->streams[i]->priv_data);
3159 av_freep(&s->streams[i]->index_entries);
3161 av_freep(&s->priv_data);
3165 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3168 AVProgram *program=NULL;
3171 if (idx >= ac->nb_streams) {
3172 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3176 for(i=0; i<ac->nb_programs; i++){
3177 if(ac->programs[i]->id != progid)
3179 program = ac->programs[i];
3180 for(j=0; j<program->nb_stream_indexes; j++)
3181 if(program->stream_index[j] == idx)
3184 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3187 program->stream_index = tmp;
3188 program->stream_index[program->nb_stream_indexes++] = idx;
3193 static void print_fps(double d, const char *postfix){
3194 uint64_t v= lrintf(d*100);
3195 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3196 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3197 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3200 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3202 if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3203 AVMetadataTag *tag=NULL;
3205 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3206 while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3207 if(strcmp("language", tag->key))
3208 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
3213 /* "user interface" functions */
3214 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3217 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3218 AVStream *st = ic->streams[i];
3219 int g = av_gcd(st->time_base.num, st->time_base.den);
3220 AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3221 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3222 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
3223 /* the pid is an important information, so we display it */
3224 /* XXX: add a generic system */
3225 if (flags & AVFMT_SHOW_IDS)
3226 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3228 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3229 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3230 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3231 if (st->sample_aspect_ratio.num && // default
3232 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3233 AVRational display_aspect_ratio;
3234 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3235 st->codec->width*st->sample_aspect_ratio.num,
3236 st->codec->height*st->sample_aspect_ratio.den,
3238 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3239 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3240 display_aspect_ratio.num, display_aspect_ratio.den);
3242 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3243 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3244 print_fps(av_q2d(st->avg_frame_rate), "fps");
3245 if(st->r_frame_rate.den && st->r_frame_rate.num)
3246 print_fps(av_q2d(st->r_frame_rate), "tbr");
3247 if(st->time_base.den && st->time_base.num)
3248 print_fps(1/av_q2d(st->time_base), "tbn");
3249 if(st->codec->time_base.den && st->codec->time_base.num)
3250 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3252 if (st->disposition & AV_DISPOSITION_DEFAULT)
3253 av_log(NULL, AV_LOG_INFO, " (default)");
3254 if (st->disposition & AV_DISPOSITION_DUB)
3255 av_log(NULL, AV_LOG_INFO, " (dub)");
3256 if (st->disposition & AV_DISPOSITION_ORIGINAL)
3257 av_log(NULL, AV_LOG_INFO, " (original)");
3258 if (st->disposition & AV_DISPOSITION_COMMENT)
3259 av_log(NULL, AV_LOG_INFO, " (comment)");
3260 if (st->disposition & AV_DISPOSITION_LYRICS)
3261 av_log(NULL, AV_LOG_INFO, " (lyrics)");
3262 if (st->disposition & AV_DISPOSITION_KARAOKE)
3263 av_log(NULL, AV_LOG_INFO, " (karaoke)");
3264 if (st->disposition & AV_DISPOSITION_FORCED)
3265 av_log(NULL, AV_LOG_INFO, " (forced)");
3266 if (st->disposition & AV_DISPOSITION_HEARING_IMPAIRED)
3267 av_log(NULL, AV_LOG_INFO, " (hearing impaired)");
3268 if (st->disposition & AV_DISPOSITION_VISUAL_IMPAIRED)
3269 av_log(NULL, AV_LOG_INFO, " (visual impaired)");
3270 if (st->disposition & AV_DISPOSITION_CLEAN_EFFECTS)
3271 av_log(NULL, AV_LOG_INFO, " (clean effects)");
3272 av_log(NULL, AV_LOG_INFO, "\n");
3273 dump_metadata(NULL, st->metadata, " ");
3276 #if FF_API_DUMP_FORMAT
3277 void dump_format(AVFormatContext *ic,
3282 av_dump_format(ic, index, url, is_output);
3286 void av_dump_format(AVFormatContext *ic,
3292 uint8_t *printed = av_mallocz(ic->nb_streams);
3293 if (ic->nb_streams && !printed)
3296 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3297 is_output ? "Output" : "Input",
3299 is_output ? ic->oformat->name : ic->iformat->name,
3300 is_output ? "to" : "from", url);
3301 dump_metadata(NULL, ic->metadata, " ");
3303 av_log(NULL, AV_LOG_INFO, " Duration: ");
3304 if (ic->duration != AV_NOPTS_VALUE) {
3305 int hours, mins, secs, us;
3306 secs = ic->duration / AV_TIME_BASE;
3307 us = ic->duration % AV_TIME_BASE;
3312 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3313 (100 * us) / AV_TIME_BASE);
3315 av_log(NULL, AV_LOG_INFO, "N/A");
3317 if (ic->start_time != AV_NOPTS_VALUE) {
3319 av_log(NULL, AV_LOG_INFO, ", start: ");
3320 secs = ic->start_time / AV_TIME_BASE;
3321 us = abs(ic->start_time % AV_TIME_BASE);
3322 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3323 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3325 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3327 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3329 av_log(NULL, AV_LOG_INFO, "N/A");
3331 av_log(NULL, AV_LOG_INFO, "\n");
3333 for (i = 0; i < ic->nb_chapters; i++) {
3334 AVChapter *ch = ic->chapters[i];
3335 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3336 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3337 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3339 dump_metadata(NULL, ch->metadata, " ");
3341 if(ic->nb_programs) {
3342 int j, k, total = 0;
3343 for(j=0; j<ic->nb_programs; j++) {
3344 AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3346 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3347 name ? name->value : "");
3348 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3349 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3350 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3351 printed[ic->programs[j]->stream_index[k]] = 1;
3353 total += ic->programs[j]->nb_stream_indexes;
3355 if (total < ic->nb_streams)
3356 av_log(NULL, AV_LOG_INFO, " No Program\n");
3358 for(i=0;i<ic->nb_streams;i++)
3360 dump_stream_format(ic, i, index, is_output);
3365 #if FF_API_PARSE_FRAME_PARAM
3366 #include "libavutil/parseutils.h"
3368 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3370 return av_parse_video_size(width_ptr, height_ptr, str);
3373 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3375 AVRational frame_rate;
3376 int ret = av_parse_video_rate(&frame_rate, arg);
3377 *frame_rate_num= frame_rate.num;
3378 *frame_rate_den= frame_rate.den;
3383 int64_t av_gettime(void)
3386 gettimeofday(&tv,NULL);
3387 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3390 uint64_t ff_ntp_time(void)
3392 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3395 #if FF_API_PARSE_DATE
3396 #include "libavutil/parseutils.h"
3398 int64_t parse_date(const char *timestr, int duration)
3401 av_parse_time(&timeval, timestr, duration);
3406 #if FF_API_FIND_INFO_TAG
3407 #include "libavutil/parseutils.h"
3409 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3411 return av_find_info_tag(arg, arg_size, tag1, info);
3415 int av_get_frame_filename(char *buf, int buf_size,
3416 const char *path, int number)
3419 char *q, buf1[20], c;
3420 int nd, len, percentd_found;
3432 while (isdigit(*p)) {
3433 nd = nd * 10 + *p++ - '0';
3436 } while (isdigit(c));
3445 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3447 if ((q - buf + len) > buf_size - 1)
3449 memcpy(q, buf1, len);
3457 if ((q - buf) < buf_size - 1)
3461 if (!percentd_found)
3470 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3474 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3476 for(i=0;i<size;i+=16) {
3483 PRINT(" %02x", buf[i+j]);
3488 for(j=0;j<len;j++) {
3490 if (c < ' ' || c > '~')
3499 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3501 hex_dump_internal(NULL, f, 0, buf, size);
3504 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3506 hex_dump_internal(avcl, NULL, level, buf, size);
3509 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload, AVRational time_base)
3512 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3513 PRINT("stream #%d:\n", pkt->stream_index);
3514 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3515 PRINT(" duration=%0.3f\n", pkt->duration * av_q2d(time_base));
3516 /* DTS is _always_ valid after av_read_frame() */
3518 if (pkt->dts == AV_NOPTS_VALUE)
3521 PRINT("%0.3f", pkt->dts * av_q2d(time_base));
3522 /* PTS may not be known if B-frames are present. */
3524 if (pkt->pts == AV_NOPTS_VALUE)
3527 PRINT("%0.3f", pkt->pts * av_q2d(time_base));
3529 PRINT(" size=%d\n", pkt->size);
3532 av_hex_dump(f, pkt->data, pkt->size);
3535 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3537 AVRational tb = { 1, AV_TIME_BASE };
3538 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, tb);
3541 void av_pkt_dump2(FILE *f, AVPacket *pkt, int dump_payload, AVStream *st)
3543 pkt_dump_internal(NULL, f, 0, pkt, dump_payload, st->time_base);
3546 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3548 AVRational tb = { 1, AV_TIME_BASE };
3549 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, tb);
3552 void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload,
3555 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload, st->time_base);
3558 #if FF_API_URL_SPLIT
3559 attribute_deprecated
3560 void ff_url_split(char *proto, int proto_size,
3561 char *authorization, int authorization_size,
3562 char *hostname, int hostname_size,
3564 char *path, int path_size,
3567 av_url_split(proto, proto_size,
3568 authorization, authorization_size,
3569 hostname, hostname_size,
3576 void av_url_split(char *proto, int proto_size,
3577 char *authorization, int authorization_size,
3578 char *hostname, int hostname_size,
3580 char *path, int path_size,
3583 const char *p, *ls, *at, *col, *brk;
3585 if (port_ptr) *port_ptr = -1;
3586 if (proto_size > 0) proto[0] = 0;
3587 if (authorization_size > 0) authorization[0] = 0;
3588 if (hostname_size > 0) hostname[0] = 0;
3589 if (path_size > 0) path[0] = 0;
3591 /* parse protocol */
3592 if ((p = strchr(url, ':'))) {
3593 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3598 /* no protocol means plain filename */
3599 av_strlcpy(path, url, path_size);
3603 /* separate path from hostname */
3604 ls = strchr(p, '/');
3606 ls = strchr(p, '?');
3608 av_strlcpy(path, ls, path_size);
3610 ls = &p[strlen(p)]; // XXX
3612 /* the rest is hostname, use that to parse auth/port */
3614 /* authorization (user[:pass]@hostname) */
3615 if ((at = strchr(p, '@')) && at < ls) {
3616 av_strlcpy(authorization, p,
3617 FFMIN(authorization_size, at + 1 - p));
3618 p = at + 1; /* skip '@' */
3621 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3623 av_strlcpy(hostname, p + 1,
3624 FFMIN(hostname_size, brk - p));
3625 if (brk[1] == ':' && port_ptr)
3626 *port_ptr = atoi(brk + 2);
3627 } else if ((col = strchr(p, ':')) && col < ls) {
3628 av_strlcpy(hostname, p,
3629 FFMIN(col + 1 - p, hostname_size));
3630 if (port_ptr) *port_ptr = atoi(col + 1);
3632 av_strlcpy(hostname, p,
3633 FFMIN(ls + 1 - p, hostname_size));
3637 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3640 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3643 'C', 'D', 'E', 'F' };
3644 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3647 'c', 'd', 'e', 'f' };
3648 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3650 for(i = 0; i < s; i++) {
3651 buff[i * 2] = hex_table[src[i] >> 4];
3652 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3658 int ff_hex_to_data(uint8_t *data, const char *p)