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
23 #include "libavcodec/internal.h"
24 #include "libavutil/opt.h"
27 #include "libavutil/avstring.h"
29 #include "audiointerleave.h"
43 * various utility functions for use within FFmpeg
46 unsigned avformat_version(void)
48 return LIBAVFORMAT_VERSION_INT;
51 const char *avformat_configuration(void)
53 return FFMPEG_CONFIGURATION;
56 const char *avformat_license(void)
58 #define LICENSE_PREFIX "libavformat license: "
59 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
62 /* fraction handling */
65 * f = val + (num / den) + 0.5.
67 * 'num' is normalized so that it is such as 0 <= num < den.
69 * @param f fractional number
70 * @param val integer value
71 * @param num must be >= 0
72 * @param den must be >= 1
74 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
87 * Fractional addition to f: f = f + (incr / f->den).
89 * @param f fractional number
90 * @param incr increment, can be positive or negative
92 static void av_frac_add(AVFrac *f, int64_t incr)
105 } else if (num >= den) {
112 /** head of registered input format linked list */
113 #if !FF_API_FIRST_FORMAT
116 AVInputFormat *first_iformat = NULL;
117 /** head of registered output format linked list */
118 #if !FF_API_FIRST_FORMAT
121 AVOutputFormat *first_oformat = NULL;
123 AVInputFormat *av_iformat_next(AVInputFormat *f)
125 if(f) return f->next;
126 else return first_iformat;
129 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
131 if(f) return f->next;
132 else return first_oformat;
135 void av_register_input_format(AVInputFormat *format)
139 while (*p != NULL) p = &(*p)->next;
144 void av_register_output_format(AVOutputFormat *format)
148 while (*p != NULL) p = &(*p)->next;
153 int av_match_ext(const char *filename, const char *extensions)
161 ext = strrchr(filename, '.');
167 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
170 if (!strcasecmp(ext1, ext))
180 static int match_format(const char *name, const char *names)
188 namelen = strlen(name);
189 while ((p = strchr(names, ','))) {
190 len = FFMAX(p - names, namelen);
191 if (!strncasecmp(name, names, len))
195 return !strcasecmp(name, names);
198 #if FF_API_GUESS_FORMAT
199 AVOutputFormat *guess_format(const char *short_name, const char *filename,
200 const char *mime_type)
202 return av_guess_format(short_name, filename, mime_type);
206 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
207 const char *mime_type)
209 AVOutputFormat *fmt = NULL, *fmt_found;
210 int score_max, score;
212 /* specific test for image sequences */
213 #if CONFIG_IMAGE2_MUXER
214 if (!short_name && filename &&
215 av_filename_number_test(filename) &&
216 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
217 return av_guess_format("image2", NULL, NULL);
220 /* Find the proper file type. */
223 while ((fmt = av_oformat_next(fmt))) {
225 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
227 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
229 if (filename && fmt->extensions &&
230 av_match_ext(filename, fmt->extensions)) {
233 if (score > score_max) {
241 #if FF_API_GUESS_FORMAT
242 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
243 const char *mime_type)
245 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
248 AVOutputFormat *stream_fmt;
249 char stream_format_name[64];
251 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
252 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
262 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
263 const char *filename, const char *mime_type, enum AVMediaType type){
264 if(type == AVMEDIA_TYPE_VIDEO){
265 enum CodecID codec_id= CODEC_ID_NONE;
267 #if CONFIG_IMAGE2_MUXER
268 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
269 codec_id= av_guess_image2_codec(filename);
272 if(codec_id == CODEC_ID_NONE)
273 codec_id= fmt->video_codec;
275 }else if(type == AVMEDIA_TYPE_AUDIO)
276 return fmt->audio_codec;
278 return CODEC_ID_NONE;
281 AVInputFormat *av_find_input_format(const char *short_name)
283 AVInputFormat *fmt = NULL;
284 while ((fmt = av_iformat_next(fmt))) {
285 if (match_format(short_name, fmt->name))
291 #if FF_API_SYMVER && CONFIG_SHARED && HAVE_SYMVER
292 FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
294 av_destruct_packet_nofree(pkt);
297 FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
299 av_destruct_packet(pkt);
302 FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
304 return av_new_packet(pkt, size);
307 FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
309 return av_dup_packet(pkt);
312 FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
317 FF_SYMVER(void, av_init_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
319 av_log(NULL, AV_LOG_WARNING, "Diverting av_*_packet function calls to libavcodec. Recompile to improve performance\n");
324 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
326 int ret= av_new_packet(pkt, size);
331 pkt->pos= url_ftell(s);
333 ret= get_buffer(s, pkt->data, size);
337 av_shrink_packet(pkt, ret);
342 int av_append_packet(ByteIOContext *s, AVPacket *pkt, int size)
347 return av_get_packet(s, pkt, size);
348 old_size = pkt->size;
349 ret = av_grow_packet(pkt, size);
352 ret = get_buffer(s, pkt->data + old_size, size);
353 av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
358 int av_filename_number_test(const char *filename)
361 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
364 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
366 AVProbeData lpd = *pd;
367 AVInputFormat *fmt1 = NULL, *fmt;
370 if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
371 int id3len = ff_id3v2_tag_len(lpd.buf);
372 if (lpd.buf_size > id3len + 16) {
374 lpd.buf_size -= id3len;
379 while ((fmt1 = av_iformat_next(fmt1))) {
380 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
383 if (fmt1->read_probe) {
384 score = fmt1->read_probe(&lpd);
385 } else if (fmt1->extensions) {
386 if (av_match_ext(lpd.filename, fmt1->extensions)) {
390 if (score > *score_max) {
393 }else if (score == *score_max)
399 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
401 return av_probe_input_format2(pd, is_opened, &score);
404 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
406 static const struct {
407 const char *name; enum CodecID id; enum AVMediaType type;
409 { "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
410 { "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
411 { "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
412 { "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
413 { "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
414 { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
415 { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
416 { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
419 AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
423 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
424 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
425 for (i = 0; fmt_id_type[i].name; i++) {
426 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
427 st->codec->codec_id = fmt_id_type[i].id;
428 st->codec->codec_type = fmt_id_type[i].type;
436 /************************************************************/
437 /* input media file */
440 * Open a media file from an IO stream. 'fmt' must be specified.
442 int av_open_input_stream(AVFormatContext **ic_ptr,
443 ByteIOContext *pb, const char *filename,
444 AVInputFormat *fmt, AVFormatParameters *ap)
448 AVFormatParameters default_ap;
452 memset(ap, 0, sizeof(default_ap));
455 if(!ap->prealloced_context)
456 ic = avformat_alloc_context();
460 err = AVERROR(ENOMEM);
465 ic->duration = AV_NOPTS_VALUE;
466 ic->start_time = AV_NOPTS_VALUE;
467 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
469 /* allocate private data */
470 if (fmt->priv_data_size > 0) {
471 ic->priv_data = av_mallocz(fmt->priv_data_size);
472 if (!ic->priv_data) {
473 err = AVERROR(ENOMEM);
477 ic->priv_data = NULL;
480 // e.g. AVFMT_NOFILE formats will not have a ByteIOContext
482 ff_id3v2_read(ic, ID3v2_DEFAULT_MAGIC);
484 if (ic->iformat->read_header) {
485 err = ic->iformat->read_header(ic, ap);
490 if (pb && !ic->data_offset)
491 ic->data_offset = url_ftell(ic->pb);
493 #if FF_API_OLD_METADATA
494 ff_metadata_demux_compat(ic);
497 ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
504 av_freep(&ic->priv_data);
505 for(i=0;i<ic->nb_streams;i++) {
506 AVStream *st = ic->streams[i];
508 av_free(st->priv_data);
509 av_free(st->codec->extradata);
521 /** size of probe buffer, for guessing file type from file contents */
522 #define PROBE_BUF_MIN 2048
523 #define PROBE_BUF_MAX (1<<20)
525 int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
526 const char *filename, void *logctx,
527 unsigned int offset, unsigned int max_probe_size)
529 AVProbeData pd = { filename ? filename : "", NULL, -offset };
530 unsigned char *buf = NULL;
531 int ret = 0, probe_size;
533 if (!max_probe_size) {
534 max_probe_size = PROBE_BUF_MAX;
535 } else if (max_probe_size > PROBE_BUF_MAX) {
536 max_probe_size = PROBE_BUF_MAX;
537 } else if (max_probe_size < PROBE_BUF_MIN) {
538 return AVERROR(EINVAL);
541 if (offset >= max_probe_size) {
542 return AVERROR(EINVAL);
545 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
546 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
547 int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
548 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
550 if (probe_size < offset) {
554 /* read probe data */
555 buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
556 if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
557 /* fail if error was not end of file, otherwise, lower score */
558 if (ret != AVERROR_EOF) {
563 ret = 0; /* error was end of file, nothing read */
566 pd.buf = &buf[offset];
568 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
570 /* guess file format */
571 *fmt = av_probe_input_format2(&pd, 1, &score);
573 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
574 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
576 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
582 return AVERROR_INVALIDDATA;
585 /* rewind. reuse probe buffer to avoid seeking */
586 if ((ret = ff_rewind_with_probe_data(*pb, buf, pd.buf_size)) < 0)
592 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
595 AVFormatParameters *ap)
598 AVProbeData probe_data, *pd = &probe_data;
599 ByteIOContext *pb = NULL;
600 void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
604 pd->filename = filename;
609 /* guess format if no file can be opened */
610 fmt = av_probe_input_format(pd, 0);
613 /* Do not open file if the format does not need it. XXX: specific
614 hack needed to handle RTSP/TCP */
615 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
616 /* if no file needed do not try to open one */
617 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
621 url_setbufsize(pb, buf_size);
623 if (!fmt && (err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
628 /* if still no format found, error */
630 err = AVERROR_INVALIDDATA;
634 /* check filename in case an image number is expected */
635 if (fmt->flags & AVFMT_NEEDNUMBER) {
636 if (!av_filename_number_test(filename)) {
637 err = AVERROR_NUMEXPECTED;
641 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
649 if (ap && ap->prealloced_context)
656 /*******************************************************/
658 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
659 AVPacketList **plast_pktl){
660 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
665 (*plast_pktl)->next = pktl;
667 *packet_buffer = pktl;
669 /* add the packet in the buffered packet list */
675 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
681 AVPacketList *pktl = s->raw_packet_buffer;
685 if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
686 !s->streams[pkt->stream_index]->probe_packets ||
687 s->raw_packet_buffer_remaining_size < pkt->size){
688 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
691 s->raw_packet_buffer = pktl->next;
692 s->raw_packet_buffer_remaining_size += pkt->size;
699 ret= s->iformat->read_packet(s, pkt);
701 if (!pktl || ret == AVERROR(EAGAIN))
703 for (i = 0; i < s->nb_streams; i++)
704 s->streams[i]->probe_packets = 0;
707 st= s->streams[pkt->stream_index];
709 switch(st->codec->codec_type){
710 case AVMEDIA_TYPE_VIDEO:
711 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
713 case AVMEDIA_TYPE_AUDIO:
714 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
716 case AVMEDIA_TYPE_SUBTITLE:
717 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
721 if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
725 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
726 s->raw_packet_buffer_remaining_size -= pkt->size;
728 if(st->codec->codec_id == CODEC_ID_PROBE){
729 AVProbeData *pd = &st->probe_data;
730 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
733 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
734 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
735 pd->buf_size += pkt->size;
736 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
738 if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
739 //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
740 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
741 if(st->codec->codec_id != CODEC_ID_PROBE){
744 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
751 /**********************************************************/
754 * Get the number of samples of an audio frame. Return -1 on error.
756 static int get_audio_frame_size(AVCodecContext *enc, int size)
760 if(enc->codec_id == CODEC_ID_VORBIS)
763 if (enc->frame_size <= 1) {
764 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
766 if (bits_per_sample) {
767 if (enc->channels == 0)
769 frame_size = (size << 3) / (bits_per_sample * enc->channels);
771 /* used for example by ADPCM codecs */
772 if (enc->bit_rate == 0)
774 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
777 frame_size = enc->frame_size;
784 * Return the frame duration in seconds. Return 0 if not available.
786 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
787 AVCodecParserContext *pc, AVPacket *pkt)
793 switch(st->codec->codec_type) {
794 case AVMEDIA_TYPE_VIDEO:
795 if(st->time_base.num*1000LL > st->time_base.den){
796 *pnum = st->time_base.num;
797 *pden = st->time_base.den;
798 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
799 *pnum = st->codec->time_base.num;
800 *pden = st->codec->time_base.den;
801 if (pc && pc->repeat_pict) {
802 *pnum = (*pnum) * (1 + pc->repeat_pict);
804 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
805 //Thus if we have no parser in such case leave duration undefined.
806 if(st->codec->ticks_per_frame>1 && !pc){
811 case AVMEDIA_TYPE_AUDIO:
812 frame_size = get_audio_frame_size(st->codec, pkt->size);
816 *pden = st->codec->sample_rate;
823 static int is_intra_only(AVCodecContext *enc){
824 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
826 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
827 switch(enc->codec_id){
829 case CODEC_ID_MJPEGB:
831 case CODEC_ID_RAWVIDEO:
832 case CODEC_ID_DVVIDEO:
833 case CODEC_ID_HUFFYUV:
834 case CODEC_ID_FFVHUFF:
839 case CODEC_ID_JPEG2000:
847 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
848 int64_t dts, int64_t pts)
850 AVStream *st= s->streams[stream_index];
851 AVPacketList *pktl= s->packet_buffer;
853 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
856 st->first_dts= dts - st->cur_dts;
859 for(; pktl; pktl= pktl->next){
860 if(pktl->pkt.stream_index != stream_index)
862 //FIXME think more about this check
863 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
864 pktl->pkt.pts += st->first_dts;
866 if(pktl->pkt.dts != AV_NOPTS_VALUE)
867 pktl->pkt.dts += st->first_dts;
869 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
870 st->start_time= pktl->pkt.pts;
872 if (st->start_time == AV_NOPTS_VALUE)
873 st->start_time = pts;
876 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
878 AVPacketList *pktl= s->packet_buffer;
881 if(st->first_dts != AV_NOPTS_VALUE){
882 cur_dts= st->first_dts;
883 for(; pktl; pktl= pktl->next){
884 if(pktl->pkt.stream_index == pkt->stream_index){
885 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
887 cur_dts -= pkt->duration;
890 pktl= s->packet_buffer;
891 st->first_dts = cur_dts;
892 }else if(st->cur_dts)
895 for(; pktl; pktl= pktl->next){
896 if(pktl->pkt.stream_index != pkt->stream_index)
898 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
899 && !pktl->pkt.duration){
900 pktl->pkt.dts= cur_dts;
901 if(!st->codec->has_b_frames)
902 pktl->pkt.pts= cur_dts;
903 cur_dts += pkt->duration;
904 pktl->pkt.duration= pkt->duration;
908 if(st->first_dts == AV_NOPTS_VALUE)
909 st->cur_dts= cur_dts;
912 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
913 AVCodecParserContext *pc, AVPacket *pkt)
915 int num, den, presentation_delayed, delay, i;
918 if (s->flags & AVFMT_FLAG_NOFILLIN)
921 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
922 pkt->dts= AV_NOPTS_VALUE;
924 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
925 //FIXME Set low_delay = 0 when has_b_frames = 1
926 st->codec->has_b_frames = 1;
928 /* do we have a video B-frame ? */
929 delay= st->codec->has_b_frames;
930 presentation_delayed = 0;
931 /* XXX: need has_b_frame, but cannot get it if the codec is
934 pc && pc->pict_type != FF_B_TYPE)
935 presentation_delayed = 1;
937 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
938 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
939 pkt->dts -= 1LL<<st->pts_wrap_bits;
942 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
943 // we take the conservative approach and discard both
944 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
945 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
946 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
947 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
950 if (pkt->duration == 0) {
951 compute_frame_duration(&num, &den, st, pc, pkt);
953 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
955 if(pkt->duration != 0 && s->packet_buffer)
956 update_initial_durations(s, st, pkt);
960 /* correct timestamps with byte offset if demuxers only have timestamps
961 on packet boundaries */
962 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
963 /* this will estimate bitrate based on this frame's duration and size */
964 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
965 if(pkt->pts != AV_NOPTS_VALUE)
967 if(pkt->dts != AV_NOPTS_VALUE)
971 if (pc && pc->dts_sync_point >= 0) {
972 // we have synchronization info from the parser
973 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
975 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
976 if (pkt->dts != AV_NOPTS_VALUE) {
977 // got DTS from the stream, update reference timestamp
978 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
979 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
980 } else if (st->reference_dts != AV_NOPTS_VALUE) {
981 // compute DTS based on reference timestamp
982 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
983 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
985 if (pc->dts_sync_point > 0)
986 st->reference_dts = pkt->dts; // new reference
990 /* This may be redundant, but it should not hurt. */
991 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
992 presentation_delayed = 1;
994 // 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);
995 /* interpolate PTS and DTS if they are not present */
996 //We skip H264 currently because delay and has_b_frames are not reliably set
997 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
998 if (presentation_delayed) {
999 /* DTS = decompression timestamp */
1000 /* PTS = presentation timestamp */
1001 if (pkt->dts == AV_NOPTS_VALUE)
1002 pkt->dts = st->last_IP_pts;
1003 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
1004 if (pkt->dts == AV_NOPTS_VALUE)
1005 pkt->dts = st->cur_dts;
1007 /* this is tricky: the dts must be incremented by the duration
1008 of the frame we are displaying, i.e. the last I- or P-frame */
1009 if (st->last_IP_duration == 0)
1010 st->last_IP_duration = pkt->duration;
1011 if(pkt->dts != AV_NOPTS_VALUE)
1012 st->cur_dts = pkt->dts + st->last_IP_duration;
1013 st->last_IP_duration = pkt->duration;
1014 st->last_IP_pts= pkt->pts;
1015 /* cannot compute PTS if not present (we can compute it only
1016 by knowing the future */
1017 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
1018 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
1019 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
1020 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
1021 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
1022 pkt->pts += pkt->duration;
1023 // 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);
1027 /* presentation is not delayed : PTS and DTS are the same */
1028 if(pkt->pts == AV_NOPTS_VALUE)
1029 pkt->pts = pkt->dts;
1030 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
1031 if(pkt->pts == AV_NOPTS_VALUE)
1032 pkt->pts = st->cur_dts;
1033 pkt->dts = pkt->pts;
1034 if(pkt->pts != AV_NOPTS_VALUE)
1035 st->cur_dts = pkt->pts + pkt->duration;
1039 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1040 st->pts_buffer[0]= pkt->pts;
1041 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1042 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1043 if(pkt->dts == AV_NOPTS_VALUE)
1044 pkt->dts= st->pts_buffer[0];
1045 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1046 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1048 if(pkt->dts > st->cur_dts)
1049 st->cur_dts = pkt->dts;
1052 // 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);
1055 if(is_intra_only(st->codec))
1056 pkt->flags |= AV_PKT_FLAG_KEY;
1059 /* keyframe computation */
1060 if (pc->key_frame == 1)
1061 pkt->flags |= AV_PKT_FLAG_KEY;
1062 else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1063 pkt->flags |= AV_PKT_FLAG_KEY;
1066 pkt->convergence_duration = pc->convergence_duration;
1070 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1075 av_init_packet(pkt);
1078 /* select current input stream component */
1081 if (!st->need_parsing || !st->parser) {
1082 /* no parsing needed: we just output the packet as is */
1083 /* raw data support */
1084 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1085 compute_pkt_fields(s, st, NULL, pkt);
1087 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1088 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1089 ff_reduce_index(s, st->index);
1090 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1093 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1094 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1095 st->cur_ptr, st->cur_len,
1096 st->cur_pkt.pts, st->cur_pkt.dts,
1098 st->cur_pkt.pts = AV_NOPTS_VALUE;
1099 st->cur_pkt.dts = AV_NOPTS_VALUE;
1100 /* increment read pointer */
1104 /* return packet if any */
1108 pkt->stream_index = st->index;
1109 pkt->pts = st->parser->pts;
1110 pkt->dts = st->parser->dts;
1111 pkt->pos = st->parser->pos;
1112 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1114 pkt->destruct= st->cur_pkt.destruct;
1115 st->cur_pkt.destruct= NULL;
1116 st->cur_pkt.data = NULL;
1117 assert(st->cur_len == 0);
1119 pkt->destruct = NULL;
1121 compute_pkt_fields(s, st, st->parser, pkt);
1123 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1124 ff_reduce_index(s, st->index);
1125 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1126 0, 0, AVINDEX_KEYFRAME);
1133 av_free_packet(&st->cur_pkt);
1138 /* read next packet */
1139 ret = av_read_packet(s, &cur_pkt);
1141 if (ret == AVERROR(EAGAIN))
1143 /* return the last frames, if any */
1144 for(i = 0; i < s->nb_streams; i++) {
1146 if (st->parser && st->need_parsing) {
1147 av_parser_parse2(st->parser, st->codec,
1148 &pkt->data, &pkt->size,
1150 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1156 /* no more packets: really terminate parsing */
1159 st = s->streams[cur_pkt.stream_index];
1160 st->cur_pkt= cur_pkt;
1162 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1163 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1164 st->cur_pkt.pts < st->cur_pkt.dts){
1165 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1166 st->cur_pkt.stream_index,
1170 // av_free_packet(&st->cur_pkt);
1174 if(s->debug & FF_FDEBUG_TS)
1175 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1176 st->cur_pkt.stream_index,
1180 st->cur_pkt.duration,
1184 st->cur_ptr = st->cur_pkt.data;
1185 st->cur_len = st->cur_pkt.size;
1186 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1187 st->parser = av_parser_init(st->codec->codec_id);
1189 /* no parser available: just output the raw packets */
1190 st->need_parsing = AVSTREAM_PARSE_NONE;
1191 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1192 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1193 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1194 st->parser->flags |= PARSER_FLAG_ONCE;
1199 if(s->debug & FF_FDEBUG_TS)
1200 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1211 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1215 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1218 pktl = s->packet_buffer;
1220 AVPacket *next_pkt= &pktl->pkt;
1222 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1223 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1224 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1225 if( pktl->pkt.stream_index == next_pkt->stream_index
1226 && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1227 && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1228 next_pkt->pts= pktl->pkt.dts;
1232 pktl = s->packet_buffer;
1235 if( next_pkt->pts != AV_NOPTS_VALUE
1236 || next_pkt->dts == AV_NOPTS_VALUE
1238 /* read packet from packet buffer, if there is data */
1240 s->packet_buffer = pktl->next;
1246 int ret= av_read_frame_internal(s, pkt);
1248 if(pktl && ret != AVERROR(EAGAIN)){
1255 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1256 &s->packet_buffer_end)) < 0)
1257 return AVERROR(ENOMEM);
1259 assert(!s->packet_buffer);
1260 return av_read_frame_internal(s, pkt);
1265 /* XXX: suppress the packet queue */
1266 static void flush_packet_queue(AVFormatContext *s)
1271 pktl = s->packet_buffer;
1274 s->packet_buffer = pktl->next;
1275 av_free_packet(&pktl->pkt);
1278 while(s->raw_packet_buffer){
1279 pktl = s->raw_packet_buffer;
1280 s->raw_packet_buffer = pktl->next;
1281 av_free_packet(&pktl->pkt);
1284 s->packet_buffer_end=
1285 s->raw_packet_buffer_end= NULL;
1286 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1289 /*******************************************************/
1292 int av_find_default_stream_index(AVFormatContext *s)
1294 int first_audio_index = -1;
1298 if (s->nb_streams <= 0)
1300 for(i = 0; i < s->nb_streams; i++) {
1302 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1305 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1306 first_audio_index = i;
1308 return first_audio_index >= 0 ? first_audio_index : 0;
1312 * Flush the frame reader.
1314 void ff_read_frame_flush(AVFormatContext *s)
1319 flush_packet_queue(s);
1323 /* for each stream, reset read state */
1324 for(i = 0; i < s->nb_streams; i++) {
1328 av_parser_close(st->parser);
1330 av_free_packet(&st->cur_pkt);
1332 st->last_IP_pts = AV_NOPTS_VALUE;
1333 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1334 st->reference_dts = AV_NOPTS_VALUE;
1339 st->probe_packets = MAX_PROBE_PACKETS;
1341 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1342 st->pts_buffer[j]= AV_NOPTS_VALUE;
1346 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1349 for(i = 0; i < s->nb_streams; i++) {
1350 AVStream *st = s->streams[i];
1352 st->cur_dts = av_rescale(timestamp,
1353 st->time_base.den * (int64_t)ref_st->time_base.num,
1354 st->time_base.num * (int64_t)ref_st->time_base.den);
1358 void ff_reduce_index(AVFormatContext *s, int stream_index)
1360 AVStream *st= s->streams[stream_index];
1361 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1363 if((unsigned)st->nb_index_entries >= max_entries){
1365 for(i=0; 2*i<st->nb_index_entries; i++)
1366 st->index_entries[i]= st->index_entries[2*i];
1367 st->nb_index_entries= i;
1371 int av_add_index_entry(AVStream *st,
1372 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1374 AVIndexEntry *entries, *ie;
1377 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1380 entries = av_fast_realloc(st->index_entries,
1381 &st->index_entries_allocated_size,
1382 (st->nb_index_entries + 1) *
1383 sizeof(AVIndexEntry));
1387 st->index_entries= entries;
1389 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1392 index= st->nb_index_entries++;
1393 ie= &entries[index];
1394 assert(index==0 || ie[-1].timestamp < timestamp);
1396 ie= &entries[index];
1397 if(ie->timestamp != timestamp){
1398 if(ie->timestamp <= timestamp)
1400 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1401 st->nb_index_entries++;
1402 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1403 distance= ie->min_distance;
1407 ie->timestamp = timestamp;
1408 ie->min_distance= distance;
1415 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1418 AVIndexEntry *entries= st->index_entries;
1419 int nb_entries= st->nb_index_entries;
1426 //optimize appending index entries at the end
1427 if(b && entries[b-1].timestamp < wanted_timestamp)
1432 timestamp = entries[m].timestamp;
1433 if(timestamp >= wanted_timestamp)
1435 if(timestamp <= wanted_timestamp)
1438 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1440 if(!(flags & AVSEEK_FLAG_ANY)){
1441 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1442 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1453 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1454 AVInputFormat *avif= s->iformat;
1455 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1456 int64_t ts_min, ts_max, ts;
1461 if (stream_index < 0)
1465 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1469 ts_min= AV_NOPTS_VALUE;
1470 pos_limit= -1; //gcc falsely says it may be uninitialized
1472 st= s->streams[stream_index];
1473 if(st->index_entries){
1476 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()
1477 index= FFMAX(index, 0);
1478 e= &st->index_entries[index];
1480 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1482 ts_min= e->timestamp;
1484 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1491 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1492 assert(index < st->nb_index_entries);
1494 e= &st->index_entries[index];
1495 assert(e->timestamp >= target_ts);
1497 ts_max= e->timestamp;
1498 pos_limit= pos_max - e->min_distance;
1500 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1501 pos_max,pos_limit, ts_max);
1506 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1511 if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1514 av_update_cur_dts(s, st, ts);
1519 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 )){
1521 int64_t start_pos, filesize;
1525 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1528 if(ts_min == AV_NOPTS_VALUE){
1529 pos_min = s->data_offset;
1530 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1531 if (ts_min == AV_NOPTS_VALUE)
1535 if(ts_max == AV_NOPTS_VALUE){
1537 filesize = url_fsize(s->pb);
1538 pos_max = filesize - 1;
1541 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1543 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1544 if (ts_max == AV_NOPTS_VALUE)
1548 int64_t tmp_pos= pos_max + 1;
1549 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1550 if(tmp_ts == AV_NOPTS_VALUE)
1554 if(tmp_pos >= filesize)
1560 if(ts_min > ts_max){
1562 }else if(ts_min == ts_max){
1567 while (pos_min < pos_limit) {
1569 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1573 assert(pos_limit <= pos_max);
1576 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1577 // interpolate position (better than dichotomy)
1578 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1579 + pos_min - approximate_keyframe_distance;
1580 }else if(no_change==1){
1581 // bisection, if interpolation failed to change min or max pos last time
1582 pos = (pos_min + pos_limit)>>1;
1584 /* linear search if bisection failed, can only happen if there
1585 are very few or no keyframes between min/max */
1590 else if(pos > pos_limit)
1594 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1600 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1601 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1602 start_pos, no_change);
1604 if(ts == AV_NOPTS_VALUE){
1605 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1608 assert(ts != AV_NOPTS_VALUE);
1609 if (target_ts <= ts) {
1610 pos_limit = start_pos - 1;
1614 if (target_ts >= ts) {
1620 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1621 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1624 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1626 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1627 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1628 pos, ts_min, target_ts, ts_max);
1634 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1635 int64_t pos_min, pos_max;
1639 if (stream_index < 0)
1642 st= s->streams[stream_index];
1645 pos_min = s->data_offset;
1646 pos_max = url_fsize(s->pb) - 1;
1648 if (pos < pos_min) pos= pos_min;
1649 else if(pos > pos_max) pos= pos_max;
1651 url_fseek(s->pb, pos, SEEK_SET);
1654 av_update_cur_dts(s, st, ts);
1659 static int av_seek_frame_generic(AVFormatContext *s,
1660 int stream_index, int64_t timestamp, int flags)
1667 st = s->streams[stream_index];
1669 index = av_index_search_timestamp(st, timestamp, flags);
1671 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1674 if(index < 0 || index==st->nb_index_entries-1){
1678 if(st->nb_index_entries){
1679 assert(st->index_entries);
1680 ie= &st->index_entries[st->nb_index_entries-1];
1681 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1683 av_update_cur_dts(s, st, ie->timestamp);
1685 if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1691 ret = av_read_frame(s, &pkt);
1692 }while(ret == AVERROR(EAGAIN));
1695 av_free_packet(&pkt);
1696 if(stream_index == pkt.stream_index){
1697 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1701 index = av_index_search_timestamp(st, timestamp, flags);
1706 ff_read_frame_flush(s);
1707 if (s->iformat->read_seek){
1708 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1711 ie = &st->index_entries[index];
1712 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1714 av_update_cur_dts(s, st, ie->timestamp);
1719 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1724 ff_read_frame_flush(s);
1726 if(flags & AVSEEK_FLAG_BYTE)
1727 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1729 if(stream_index < 0){
1730 stream_index= av_find_default_stream_index(s);
1731 if(stream_index < 0)
1734 st= s->streams[stream_index];
1735 /* timestamp for default must be expressed in AV_TIME_BASE units */
1736 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1739 /* first, we try the format specific seek */
1740 if (s->iformat->read_seek)
1741 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1748 if(s->iformat->read_timestamp)
1749 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1751 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1754 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1756 if(min_ts > ts || max_ts < ts)
1759 ff_read_frame_flush(s);
1761 if (s->iformat->read_seek2)
1762 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1764 if(s->iformat->read_timestamp){
1765 //try to seek via read_timestamp()
1768 //Fallback to old API if new is not implemented but old is
1769 //Note the old has somewat different sematics
1770 if(s->iformat->read_seek || 1)
1771 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1773 // try some generic seek like av_seek_frame_generic() but with new ts semantics
1776 /*******************************************************/
1779 * Return TRUE if the stream has accurate duration in any stream.
1781 * @return TRUE if the stream has accurate duration for at least one component.
1783 static int av_has_duration(AVFormatContext *ic)
1788 for(i = 0;i < ic->nb_streams; i++) {
1789 st = ic->streams[i];
1790 if (st->duration != AV_NOPTS_VALUE)
1797 * Estimate the stream timings from the one of each components.
1799 * Also computes the global bitrate if possible.
1801 static void av_update_stream_timings(AVFormatContext *ic)
1803 int64_t start_time, start_time1, end_time, end_time1;
1804 int64_t duration, duration1;
1808 start_time = INT64_MAX;
1809 end_time = INT64_MIN;
1810 duration = INT64_MIN;
1811 for(i = 0;i < ic->nb_streams; i++) {
1812 st = ic->streams[i];
1813 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1814 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1815 if (start_time1 < start_time)
1816 start_time = start_time1;
1817 if (st->duration != AV_NOPTS_VALUE) {
1818 end_time1 = start_time1
1819 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1820 if (end_time1 > end_time)
1821 end_time = end_time1;
1824 if (st->duration != AV_NOPTS_VALUE) {
1825 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1826 if (duration1 > duration)
1827 duration = duration1;
1830 if (start_time != INT64_MAX) {
1831 ic->start_time = start_time;
1832 if (end_time != INT64_MIN) {
1833 if (end_time - start_time > duration)
1834 duration = end_time - start_time;
1837 if (duration != INT64_MIN) {
1838 ic->duration = duration;
1839 if (ic->file_size > 0) {
1840 /* compute the bitrate */
1841 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1842 (double)ic->duration;
1847 static void fill_all_stream_timings(AVFormatContext *ic)
1852 av_update_stream_timings(ic);
1853 for(i = 0;i < ic->nb_streams; i++) {
1854 st = ic->streams[i];
1855 if (st->start_time == AV_NOPTS_VALUE) {
1856 if(ic->start_time != AV_NOPTS_VALUE)
1857 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1858 if(ic->duration != AV_NOPTS_VALUE)
1859 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1864 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1866 int64_t filesize, duration;
1870 /* if bit_rate is already set, we believe it */
1871 if (ic->bit_rate == 0) {
1873 for(i=0;i<ic->nb_streams;i++) {
1874 st = ic->streams[i];
1875 bit_rate += st->codec->bit_rate;
1877 ic->bit_rate = bit_rate;
1880 /* if duration is already set, we believe it */
1881 if (ic->duration == AV_NOPTS_VALUE &&
1882 ic->bit_rate != 0 &&
1883 ic->file_size != 0) {
1884 filesize = ic->file_size;
1886 for(i = 0; i < ic->nb_streams; i++) {
1887 st = ic->streams[i];
1888 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1889 if (st->duration == AV_NOPTS_VALUE)
1890 st->duration = duration;
1896 #define DURATION_MAX_READ_SIZE 250000
1897 #define DURATION_MAX_RETRY 3
1899 /* only usable for MPEG-PS streams */
1900 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1902 AVPacket pkt1, *pkt = &pkt1;
1904 int read_size, i, ret;
1906 int64_t filesize, offset, duration;
1911 /* flush packet queue */
1912 flush_packet_queue(ic);
1914 for (i=0; i<ic->nb_streams; i++) {
1915 st = ic->streams[i];
1916 if (st->start_time == AV_NOPTS_VALUE && st->first_dts == AV_NOPTS_VALUE)
1917 av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1920 av_parser_close(st->parser);
1922 av_free_packet(&st->cur_pkt);
1926 /* estimate the end time (duration) */
1927 /* XXX: may need to support wrapping */
1928 filesize = ic->file_size;
1929 end_time = AV_NOPTS_VALUE;
1931 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1935 url_fseek(ic->pb, offset, SEEK_SET);
1938 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1942 ret = av_read_packet(ic, pkt);
1943 }while(ret == AVERROR(EAGAIN));
1946 read_size += pkt->size;
1947 st = ic->streams[pkt->stream_index];
1948 if (pkt->pts != AV_NOPTS_VALUE &&
1949 (st->start_time != AV_NOPTS_VALUE ||
1950 st->first_dts != AV_NOPTS_VALUE)) {
1951 duration = end_time = pkt->pts;
1952 if (st->start_time != AV_NOPTS_VALUE) duration -= st->start_time;
1953 else duration -= st->first_dts;
1955 duration += 1LL<<st->pts_wrap_bits;
1957 if (st->duration == AV_NOPTS_VALUE ||
1958 st->duration < duration)
1959 st->duration = duration;
1962 av_free_packet(pkt);
1964 }while( end_time==AV_NOPTS_VALUE
1965 && filesize > (DURATION_MAX_READ_SIZE<<retry)
1966 && ++retry <= DURATION_MAX_RETRY);
1968 fill_all_stream_timings(ic);
1970 url_fseek(ic->pb, old_offset, SEEK_SET);
1971 for (i=0; i<ic->nb_streams; i++) {
1973 st->cur_dts= st->first_dts;
1974 st->last_IP_pts = AV_NOPTS_VALUE;
1978 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1982 /* get the file size, if possible */
1983 if (ic->iformat->flags & AVFMT_NOFILE) {
1986 file_size = url_fsize(ic->pb);
1990 ic->file_size = file_size;
1992 if ((!strcmp(ic->iformat->name, "mpeg") ||
1993 !strcmp(ic->iformat->name, "mpegts")) &&
1994 file_size && !url_is_streamed(ic->pb)) {
1995 /* get accurate estimate from the PTSes */
1996 av_estimate_timings_from_pts(ic, old_offset);
1997 } else if (av_has_duration(ic)) {
1998 /* at least one component has timings - we use them for all
2000 fill_all_stream_timings(ic);
2002 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
2003 /* less precise: use bitrate info */
2004 av_estimate_timings_from_bit_rate(ic);
2006 av_update_stream_timings(ic);
2012 for(i = 0;i < ic->nb_streams; i++) {
2013 st = ic->streams[i];
2014 printf("%d: start_time: %0.3f duration: %0.3f\n",
2015 i, (double)st->start_time / AV_TIME_BASE,
2016 (double)st->duration / AV_TIME_BASE);
2018 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
2019 (double)ic->start_time / AV_TIME_BASE,
2020 (double)ic->duration / AV_TIME_BASE,
2021 ic->bit_rate / 1000);
2026 static int has_codec_parameters(AVCodecContext *enc)
2029 switch(enc->codec_type) {
2030 case AVMEDIA_TYPE_AUDIO:
2031 val = enc->sample_rate && enc->channels && enc->sample_fmt != AV_SAMPLE_FMT_NONE;
2032 if(!enc->frame_size &&
2033 (enc->codec_id == CODEC_ID_VORBIS ||
2034 enc->codec_id == CODEC_ID_AAC ||
2035 enc->codec_id == CODEC_ID_MP1 ||
2036 enc->codec_id == CODEC_ID_MP2 ||
2037 enc->codec_id == CODEC_ID_MP3 ||
2038 enc->codec_id == CODEC_ID_SPEEX))
2041 case AVMEDIA_TYPE_VIDEO:
2042 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2048 return enc->codec_id != CODEC_ID_NONE && val != 0;
2051 static int has_decode_delay_been_guessed(AVStream *st)
2053 return st->codec->codec_id != CODEC_ID_H264 ||
2054 st->codec_info_nb_frames >= 6 + st->codec->has_b_frames;
2057 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2061 int got_picture, data_size, ret=0;
2064 if(!st->codec->codec){
2065 codec = avcodec_find_decoder(st->codec->codec_id);
2068 ret = avcodec_open(st->codec, codec);
2073 if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2074 switch(st->codec->codec_type) {
2075 case AVMEDIA_TYPE_VIDEO:
2076 avcodec_get_frame_defaults(&picture);
2077 ret = avcodec_decode_video2(st->codec, &picture,
2078 &got_picture, avpkt);
2080 case AVMEDIA_TYPE_AUDIO:
2081 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2082 samples = av_malloc(data_size);
2085 ret = avcodec_decode_audio3(st->codec, samples,
2097 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2099 while (tags->id != CODEC_ID_NONE) {
2107 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2110 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2111 if(tag == tags[i].tag)
2114 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2115 if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2118 return CODEC_ID_NONE;
2121 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2124 for(i=0; tags && tags[i]; i++){
2125 int tag= ff_codec_get_tag(tags[i], id);
2131 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2134 for(i=0; tags && tags[i]; i++){
2135 enum CodecID id= ff_codec_get_id(tags[i], tag);
2136 if(id!=CODEC_ID_NONE) return id;
2138 return CODEC_ID_NONE;
2141 static void compute_chapters_end(AVFormatContext *s)
2145 for (i=0; i+1<s->nb_chapters; i++)
2146 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2147 assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2148 assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2149 s->chapters[i]->end = s->chapters[i+1]->start;
2152 if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2153 assert(s->start_time != AV_NOPTS_VALUE);
2154 assert(s->duration > 0);
2155 s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2157 s->chapters[i]->time_base);
2161 static int get_std_framerate(int i){
2162 if(i<60*12) return i*1001;
2163 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2167 * Is the time base unreliable.
2168 * This is a heuristic to balance between quick acceptance of the values in
2169 * the headers vs. some extra checks.
2170 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2171 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2172 * And there are "variable" fps files this needs to detect as well.
2174 static int tb_unreliable(AVCodecContext *c){
2175 if( c->time_base.den >= 101L*c->time_base.num
2176 || c->time_base.den < 5L*c->time_base.num
2177 /* || c->codec_tag == AV_RL32("DIVX")
2178 || c->codec_tag == AV_RL32("XVID")*/
2179 || c->codec_id == CODEC_ID_MPEG2VIDEO
2180 || c->codec_id == CODEC_ID_H264
2186 int av_find_stream_info(AVFormatContext *ic)
2188 int i, count, ret, read_size, j;
2190 AVPacket pkt1, *pkt;
2191 int64_t old_offset = url_ftell(ic->pb);
2193 for(i=0;i<ic->nb_streams;i++) {
2195 st = ic->streams[i];
2196 if (st->codec->codec_id == CODEC_ID_AAC) {
2197 st->codec->sample_rate = 0;
2198 st->codec->frame_size = 0;
2199 st->codec->channels = 0;
2201 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2202 st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2203 /* if(!st->time_base.num)
2205 if(!st->codec->time_base.num)
2206 st->codec->time_base= st->time_base;
2208 //only for the split stuff
2209 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2210 st->parser = av_parser_init(st->codec->codec_id);
2211 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2212 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2215 assert(!st->codec->codec);
2216 codec = avcodec_find_decoder(st->codec->codec_id);
2218 /* Force decoding of at least one frame of codec data
2219 * this makes sure the codec initializes the channel configuration
2220 * and does not trust the values from the container.
2222 if (codec && codec->capabilities & CODEC_CAP_CHANNEL_CONF)
2223 st->codec->channels = 0;
2225 /* Ensure that subtitle_header is properly set. */
2226 if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE
2227 && codec && !st->codec->codec)
2228 avcodec_open(st->codec, codec);
2230 //try to just open decoders, in case this is enough to get parameters
2231 if(!has_codec_parameters(st->codec)){
2232 if (codec && !st->codec->codec)
2233 avcodec_open(st->codec, codec);
2237 for (i=0; i<ic->nb_streams; i++) {
2238 ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
2244 if(url_interrupt_cb()){
2245 ret= AVERROR(EINTR);
2246 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2250 /* check if one codec still needs to be handled */
2251 for(i=0;i<ic->nb_streams;i++) {
2252 st = ic->streams[i];
2253 if (!has_codec_parameters(st->codec))
2255 /* variable fps and no guess at the real fps */
2256 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2257 && st->info->duration_count<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2259 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2261 if(st->first_dts == AV_NOPTS_VALUE)
2264 if (i == ic->nb_streams) {
2265 /* NOTE: if the format has no header, then we need to read
2266 some packets to get most of the streams, so we cannot
2268 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2269 /* if we found the info for all the codecs, we can stop */
2271 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2275 /* we did not get all the codec info, but we read too much data */
2276 if (read_size >= ic->probesize) {
2278 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2282 /* NOTE: a new stream can be added there if no header in file
2283 (AVFMTCTX_NOHEADER) */
2284 ret = av_read_frame_internal(ic, &pkt1);
2285 if (ret < 0 && ret != AVERROR(EAGAIN)) {
2287 ret = -1; /* we could not have all the codec parameters before EOF */
2288 for(i=0;i<ic->nb_streams;i++) {
2289 st = ic->streams[i];
2290 if (!has_codec_parameters(st->codec)){
2292 avcodec_string(buf, sizeof(buf), st->codec, 0);
2293 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2301 if (ret == AVERROR(EAGAIN))
2304 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2305 if ((ret = av_dup_packet(pkt)) < 0)
2306 goto find_stream_info_err;
2308 read_size += pkt->size;
2310 st = ic->streams[pkt->stream_index];
2311 if (st->codec_info_nb_frames>1) {
2312 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) {
2313 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2316 st->info->codec_info_duration += pkt->duration;
2319 int64_t last = st->info->last_dts;
2320 int64_t duration= pkt->dts - last;
2322 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2323 double dur= duration * av_q2d(st->time_base);
2325 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2326 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2327 if (st->info->duration_count < 2)
2328 memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
2329 for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
2330 int framerate= get_std_framerate(i);
2331 int ticks= lrintf(dur*framerate/(1001*12));
2332 double error= dur - ticks*1001*12/(double)framerate;
2333 st->info->duration_error[i] += error*error;
2335 st->info->duration_count++;
2336 // ignore the first 4 values, they might have some random jitter
2337 if (st->info->duration_count > 3)
2338 st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
2340 if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
2341 st->info->last_dts = pkt->dts;
2343 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2344 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2346 st->codec->extradata_size= i;
2347 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2348 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2349 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2353 /* if still no information, we try to open the codec and to
2354 decompress the frame. We try to avoid that in most cases as
2355 it takes longer and uses more memory. For MPEG-4, we need to
2356 decompress for QuickTime. */
2357 if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2358 try_decode_frame(st, pkt);
2360 st->codec_info_nb_frames++;
2364 // close codecs which were opened in try_decode_frame()
2365 for(i=0;i<ic->nb_streams;i++) {
2366 st = ic->streams[i];
2367 if(st->codec->codec)
2368 avcodec_close(st->codec);
2370 for(i=0;i<ic->nb_streams;i++) {
2371 st = ic->streams[i];
2372 if (st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && st->info->codec_info_duration)
2373 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2374 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2375 st->info->codec_info_duration*(int64_t)st->time_base.num, 60000);
2376 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2377 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2378 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2380 // the check for tb_unreliable() is not completely correct, since this is not about handling
2381 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2382 // ipmovie.c produces.
2383 if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
2384 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);
2385 if (st->info->duration_count && !st->r_frame_rate.num
2386 && tb_unreliable(st->codec) /*&&
2387 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2388 st->time_base.num*duration_sum[i]/st->info->duration_count*101LL > st->time_base.den*/){
2390 double best_error= 2*av_q2d(st->time_base);
2391 best_error = best_error*best_error*st->info->duration_count*1000*12*30;
2393 for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
2394 double error = st->info->duration_error[j] * get_std_framerate(j);
2395 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2396 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2397 if(error < best_error){
2399 num = get_std_framerate(j);
2402 // do not increase frame rate by more than 1 % in order to match a standard rate.
2403 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2404 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2407 if (!st->r_frame_rate.num){
2408 if( st->codec->time_base.den * (int64_t)st->time_base.num
2409 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2410 st->r_frame_rate.num = st->codec->time_base.den;
2411 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2413 st->r_frame_rate.num = st->time_base.den;
2414 st->r_frame_rate.den = st->time_base.num;
2417 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2418 if(!st->codec->bits_per_coded_sample)
2419 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2423 av_estimate_timings(ic, old_offset);
2425 compute_chapters_end(ic);
2428 /* correct DTS for B-frame streams with no timestamps */
2429 for(i=0;i<ic->nb_streams;i++) {
2430 st = ic->streams[i];
2431 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2433 ppktl = &ic->packet_buffer;
2435 if(ppkt1->stream_index != i)
2437 if(ppkt1->pkt->dts < 0)
2439 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2441 ppkt1->pkt->dts -= delta;
2446 st->cur_dts -= delta;
2452 find_stream_info_err:
2453 for (i=0; i < ic->nb_streams; i++)
2454 av_freep(&ic->streams[i]->info);
2458 /*******************************************************/
2460 int av_read_play(AVFormatContext *s)
2462 if (s->iformat->read_play)
2463 return s->iformat->read_play(s);
2465 return av_url_read_fpause(s->pb, 0);
2466 return AVERROR(ENOSYS);
2469 int av_read_pause(AVFormatContext *s)
2471 if (s->iformat->read_pause)
2472 return s->iformat->read_pause(s);
2474 return av_url_read_fpause(s->pb, 1);
2475 return AVERROR(ENOSYS);
2478 void av_close_input_stream(AVFormatContext *s)
2483 if (s->iformat->read_close)
2484 s->iformat->read_close(s);
2485 for(i=0;i<s->nb_streams;i++) {
2486 /* free all data in a stream component */
2489 av_parser_close(st->parser);
2490 av_free_packet(&st->cur_pkt);
2492 av_metadata_free(&st->metadata);
2493 av_free(st->index_entries);
2494 av_free(st->codec->extradata);
2495 av_free(st->codec->subtitle_header);
2497 #if FF_API_OLD_METADATA
2498 av_free(st->filename);
2500 av_free(st->priv_data);
2504 for(i=s->nb_programs-1; i>=0; i--) {
2505 #if FF_API_OLD_METADATA
2506 av_freep(&s->programs[i]->provider_name);
2507 av_freep(&s->programs[i]->name);
2509 av_metadata_free(&s->programs[i]->metadata);
2510 av_freep(&s->programs[i]->stream_index);
2511 av_freep(&s->programs[i]);
2513 av_freep(&s->programs);
2514 flush_packet_queue(s);
2515 av_freep(&s->priv_data);
2516 while(s->nb_chapters--) {
2517 #if FF_API_OLD_METADATA
2518 av_free(s->chapters[s->nb_chapters]->title);
2520 av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2521 av_free(s->chapters[s->nb_chapters]);
2523 av_freep(&s->chapters);
2524 av_metadata_free(&s->metadata);
2529 void av_close_input_file(AVFormatContext *s)
2531 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2532 av_close_input_stream(s);
2537 AVStream *av_new_stream(AVFormatContext *s, int id)
2542 #if FF_API_MAX_STREAMS
2543 if (s->nb_streams >= MAX_STREAMS){
2544 av_log(s, AV_LOG_ERROR, "Too many streams\n");
2550 if (s->nb_streams >= INT_MAX/sizeof(*streams))
2552 streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
2555 s->streams = streams;
2558 st = av_mallocz(sizeof(AVStream));
2561 if (!(st->info = av_mallocz(sizeof(*st->info)))) {
2566 st->codec= avcodec_alloc_context();
2568 /* no default bitrate if decoding */
2569 st->codec->bit_rate = 0;
2571 st->index = s->nb_streams;
2573 st->start_time = AV_NOPTS_VALUE;
2574 st->duration = AV_NOPTS_VALUE;
2575 /* we set the current DTS to 0 so that formats without any timestamps
2576 but durations get some timestamps, formats with some unknown
2577 timestamps have their first few packets buffered and the
2578 timestamps corrected before they are returned to the user */
2580 st->first_dts = AV_NOPTS_VALUE;
2581 st->probe_packets = MAX_PROBE_PACKETS;
2583 /* default pts setting is MPEG-like */
2584 av_set_pts_info(st, 33, 1, 90000);
2585 st->last_IP_pts = AV_NOPTS_VALUE;
2586 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2587 st->pts_buffer[i]= AV_NOPTS_VALUE;
2588 st->reference_dts = AV_NOPTS_VALUE;
2590 st->sample_aspect_ratio = (AVRational){0,1};
2592 s->streams[s->nb_streams++] = st;
2596 AVProgram *av_new_program(AVFormatContext *ac, int id)
2598 AVProgram *program=NULL;
2602 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2605 for(i=0; i<ac->nb_programs; i++)
2606 if(ac->programs[i]->id == id)
2607 program = ac->programs[i];
2610 program = av_mallocz(sizeof(AVProgram));
2613 dynarray_add(&ac->programs, &ac->nb_programs, program);
2614 program->discard = AVDISCARD_NONE;
2621 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2623 AVChapter *chapter = NULL;
2626 for(i=0; i<s->nb_chapters; i++)
2627 if(s->chapters[i]->id == id)
2628 chapter = s->chapters[i];
2631 chapter= av_mallocz(sizeof(AVChapter));
2634 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2636 #if FF_API_OLD_METADATA
2637 av_free(chapter->title);
2639 av_metadata_set2(&chapter->metadata, "title", title, 0);
2641 chapter->time_base= time_base;
2642 chapter->start = start;
2648 /************************************************************/
2649 /* output media file */
2651 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2655 if (s->oformat->priv_data_size > 0) {
2656 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2658 return AVERROR(ENOMEM);
2660 s->priv_data = NULL;
2662 if (s->oformat->set_parameters) {
2663 ret = s->oformat->set_parameters(s, ap);
2670 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2672 const AVCodecTag *avctag;
2674 enum CodecID id = CODEC_ID_NONE;
2675 unsigned int tag = 0;
2678 * Check that tag + id is in the table
2679 * If neither is in the table -> OK
2680 * If tag is in the table with another id -> FAIL
2681 * If id is in the table with another tag -> FAIL unless strict < normal
2683 for (n = 0; s->oformat->codec_tag[n]; n++) {
2684 avctag = s->oformat->codec_tag[n];
2685 while (avctag->id != CODEC_ID_NONE) {
2686 if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2688 if (id == st->codec->codec_id)
2691 if (avctag->id == st->codec->codec_id)
2696 if (id != CODEC_ID_NONE)
2698 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2703 int av_write_header(AVFormatContext *s)
2708 // some sanity checks
2709 if (s->nb_streams == 0) {
2710 av_log(s, AV_LOG_ERROR, "no streams\n");
2711 return AVERROR(EINVAL);
2714 for(i=0;i<s->nb_streams;i++) {
2717 switch (st->codec->codec_type) {
2718 case AVMEDIA_TYPE_AUDIO:
2719 if(st->codec->sample_rate<=0){
2720 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2721 return AVERROR(EINVAL);
2723 if(!st->codec->block_align)
2724 st->codec->block_align = st->codec->channels *
2725 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2727 case AVMEDIA_TYPE_VIDEO:
2728 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2729 av_log(s, AV_LOG_ERROR, "time base not set\n");
2730 return AVERROR(EINVAL);
2732 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2733 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2734 return AVERROR(EINVAL);
2736 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2737 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2738 return AVERROR(EINVAL);
2743 if(s->oformat->codec_tag){
2744 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)){
2745 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2746 st->codec->codec_tag= 0;
2748 if(st->codec->codec_tag){
2749 if (!validate_codec_tag(s, st)) {
2751 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2752 av_log(s, AV_LOG_ERROR,
2753 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2754 tagbuf, st->codec->codec_tag, st->codec->codec_id);
2755 return AVERROR_INVALIDDATA;
2758 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2761 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2762 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2763 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2766 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2767 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2769 return AVERROR(ENOMEM);
2772 #if FF_API_OLD_METADATA
2773 ff_metadata_mux_compat(s);
2776 /* set muxer identification string */
2777 if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2778 av_metadata_set2(&s->metadata, "encoder", LIBAVFORMAT_IDENT, 0);
2781 if(s->oformat->write_header){
2782 ret = s->oformat->write_header(s);
2787 /* init PTS generation */
2788 for(i=0;i<s->nb_streams;i++) {
2789 int64_t den = AV_NOPTS_VALUE;
2792 switch (st->codec->codec_type) {
2793 case AVMEDIA_TYPE_AUDIO:
2794 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2796 case AVMEDIA_TYPE_VIDEO:
2797 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2802 if (den != AV_NOPTS_VALUE) {
2804 return AVERROR_INVALIDDATA;
2805 av_frac_init(&st->pts, 0, 0, den);
2811 //FIXME merge with compute_pkt_fields
2812 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2813 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2814 int num, den, frame_size, i;
2816 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts:%"PRId64" dts:%"PRId64" cur_dts:%"PRId64" b:%d size:%d st:%d\n", pkt->pts, pkt->dts, st->cur_dts, delay, pkt->size, pkt->stream_index);
2818 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2821 /* duration field */
2822 if (pkt->duration == 0) {
2823 compute_frame_duration(&num, &den, st, NULL, pkt);
2825 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2829 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2832 //XXX/FIXME this is a temporary hack until all encoders output pts
2833 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2835 // pkt->pts= st->cur_dts;
2836 pkt->pts= st->pts.val;
2839 //calculate dts from pts
2840 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2841 st->pts_buffer[0]= pkt->pts;
2842 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2843 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2844 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2845 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2847 pkt->dts= st->pts_buffer[0];
2850 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2851 av_log(s, AV_LOG_ERROR,
2852 "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2853 st->index, st->cur_dts, pkt->dts);
2856 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2857 av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2861 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2862 st->cur_dts= pkt->dts;
2863 st->pts.val= pkt->dts;
2866 switch (st->codec->codec_type) {
2867 case AVMEDIA_TYPE_AUDIO:
2868 frame_size = get_audio_frame_size(st->codec, pkt->size);
2870 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2871 likely equal to the encoder delay, but it would be better if we
2872 had the real timestamps from the encoder */
2873 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2874 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2877 case AVMEDIA_TYPE_VIDEO:
2878 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2886 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2888 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2890 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2893 ret= s->oformat->write_packet(s, pkt);
2895 ret= url_ferror(s->pb);
2899 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2900 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2902 AVPacketList **next_point, *this_pktl;
2904 this_pktl = av_mallocz(sizeof(AVPacketList));
2905 this_pktl->pkt= *pkt;
2906 pkt->destruct= NULL; // do not free original but only the copy
2907 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
2909 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2910 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2912 next_point = &s->packet_buffer;
2915 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2916 while(!compare(s, &(*next_point)->pkt, pkt)){
2917 next_point= &(*next_point)->next;
2921 next_point = &(s->packet_buffer_end->next);
2924 assert(!*next_point);
2926 s->packet_buffer_end= this_pktl;
2929 this_pktl->next= *next_point;
2931 s->streams[pkt->stream_index]->last_in_packet_buffer=
2932 *next_point= this_pktl;
2935 int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2937 AVStream *st = s->streams[ pkt ->stream_index];
2938 AVStream *st2= s->streams[ next->stream_index];
2939 int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2940 int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2941 return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2944 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2950 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2953 for(i=0; i < s->nb_streams; i++)
2954 stream_count+= !!s->streams[i]->last_in_packet_buffer;
2956 if(stream_count && (s->nb_streams == stream_count || flush)){
2957 pktl= s->packet_buffer;
2960 s->packet_buffer= pktl->next;
2961 if(!s->packet_buffer)
2962 s->packet_buffer_end= NULL;
2964 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2965 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2969 av_init_packet(out);
2975 * Interleave an AVPacket correctly so it can be muxed.
2976 * @param out the interleaved packet will be output here
2977 * @param in the input packet
2978 * @param flush 1 if no further packets are available as input and all
2979 * remaining packets should be output
2980 * @return 1 if a packet was output, 0 if no packet could be output,
2981 * < 0 if an error occurred
2983 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2984 if(s->oformat->interleave_packet)
2985 return s->oformat->interleave_packet(s, out, in, flush);
2987 return av_interleave_packet_per_dts(s, out, in, flush);
2990 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2991 AVStream *st= s->streams[ pkt->stream_index];
2993 //FIXME/XXX/HACK drop zero sized packets
2994 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2997 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2998 if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3001 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
3006 int ret= av_interleave_packet(s, &opkt, pkt, 0);
3007 if(ret<=0) //FIXME cleanup needed for ret<0 ?
3010 ret= s->oformat->write_packet(s, &opkt);
3012 av_free_packet(&opkt);
3017 if(url_ferror(s->pb))
3018 return url_ferror(s->pb);
3022 int av_write_trailer(AVFormatContext *s)
3028 ret= av_interleave_packet(s, &pkt, NULL, 1);
3029 if(ret<0) //FIXME cleanup needed for ret<0 ?
3034 ret= s->oformat->write_packet(s, &pkt);
3036 av_free_packet(&pkt);
3040 if(url_ferror(s->pb))
3044 if(s->oformat->write_trailer)
3045 ret = s->oformat->write_trailer(s);
3048 ret=url_ferror(s->pb);
3049 for(i=0;i<s->nb_streams;i++) {
3050 av_freep(&s->streams[i]->priv_data);
3051 av_freep(&s->streams[i]->index_entries);
3053 av_freep(&s->priv_data);
3057 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3060 AVProgram *program=NULL;
3063 if (idx >= ac->nb_streams) {
3064 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3068 for(i=0; i<ac->nb_programs; i++){
3069 if(ac->programs[i]->id != progid)
3071 program = ac->programs[i];
3072 for(j=0; j<program->nb_stream_indexes; j++)
3073 if(program->stream_index[j] == idx)
3076 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3079 program->stream_index = tmp;
3080 program->stream_index[program->nb_stream_indexes++] = idx;
3085 static void print_fps(double d, const char *postfix){
3086 uint64_t v= lrintf(d*100);
3087 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3088 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3089 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3092 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3094 if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3095 AVMetadataTag *tag=NULL;
3097 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3098 while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3099 if(strcmp("language", tag->key))
3100 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
3105 /* "user interface" functions */
3106 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3109 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3110 AVStream *st = ic->streams[i];
3111 int g = av_gcd(st->time_base.num, st->time_base.den);
3112 AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3113 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3114 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
3115 /* the pid is an important information, so we display it */
3116 /* XXX: add a generic system */
3117 if (flags & AVFMT_SHOW_IDS)
3118 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3120 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3121 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3122 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3123 if (st->sample_aspect_ratio.num && // default
3124 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3125 AVRational display_aspect_ratio;
3126 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3127 st->codec->width*st->sample_aspect_ratio.num,
3128 st->codec->height*st->sample_aspect_ratio.den,
3130 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3131 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3132 display_aspect_ratio.num, display_aspect_ratio.den);
3134 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3135 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3136 print_fps(av_q2d(st->avg_frame_rate), "fps");
3137 if(st->r_frame_rate.den && st->r_frame_rate.num)
3138 print_fps(av_q2d(st->r_frame_rate), "tbr");
3139 if(st->time_base.den && st->time_base.num)
3140 print_fps(1/av_q2d(st->time_base), "tbn");
3141 if(st->codec->time_base.den && st->codec->time_base.num)
3142 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3144 av_log(NULL, AV_LOG_INFO, "\n");
3145 dump_metadata(NULL, st->metadata, " ");
3148 void dump_format(AVFormatContext *ic,
3154 uint8_t *printed = av_mallocz(ic->nb_streams);
3155 if (ic->nb_streams && !printed)
3158 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3159 is_output ? "Output" : "Input",
3161 is_output ? ic->oformat->name : ic->iformat->name,
3162 is_output ? "to" : "from", url);
3163 dump_metadata(NULL, ic->metadata, " ");
3165 av_log(NULL, AV_LOG_INFO, " Duration: ");
3166 if (ic->duration != AV_NOPTS_VALUE) {
3167 int hours, mins, secs, us;
3168 secs = ic->duration / AV_TIME_BASE;
3169 us = ic->duration % AV_TIME_BASE;
3174 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3175 (100 * us) / AV_TIME_BASE);
3177 av_log(NULL, AV_LOG_INFO, "N/A");
3179 if (ic->start_time != AV_NOPTS_VALUE) {
3181 av_log(NULL, AV_LOG_INFO, ", start: ");
3182 secs = ic->start_time / AV_TIME_BASE;
3183 us = abs(ic->start_time % AV_TIME_BASE);
3184 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3185 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3187 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3189 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3191 av_log(NULL, AV_LOG_INFO, "N/A");
3193 av_log(NULL, AV_LOG_INFO, "\n");
3195 for (i = 0; i < ic->nb_chapters; i++) {
3196 AVChapter *ch = ic->chapters[i];
3197 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3198 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3199 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3201 dump_metadata(NULL, ch->metadata, " ");
3203 if(ic->nb_programs) {
3204 int j, k, total = 0;
3205 for(j=0; j<ic->nb_programs; j++) {
3206 AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3208 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3209 name ? name->value : "");
3210 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3211 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3212 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3213 printed[ic->programs[j]->stream_index[k]] = 1;
3215 total += ic->programs[j]->nb_stream_indexes;
3217 if (total < ic->nb_streams)
3218 av_log(NULL, AV_LOG_INFO, " No Program\n");
3220 for(i=0;i<ic->nb_streams;i++)
3222 dump_stream_format(ic, i, index, is_output);
3227 #if FF_API_PARSE_FRAME_PARAM
3228 #include "libavcore/parseutils.h"
3230 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3232 return av_parse_video_size(width_ptr, height_ptr, str);
3235 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3237 AVRational frame_rate;
3238 int ret = av_parse_video_rate(&frame_rate, arg);
3239 *frame_rate_num= frame_rate.num;
3240 *frame_rate_den= frame_rate.den;
3245 int64_t av_gettime(void)
3248 gettimeofday(&tv,NULL);
3249 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3252 uint64_t ff_ntp_time(void)
3254 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3257 int64_t parse_date(const char *datestr, int duration)
3263 static const char * const date_fmt[] = {
3267 static const char * const time_fmt[] = {
3277 time_t now = time(0);
3279 len = strlen(datestr);
3281 lastch = datestr[len - 1];
3284 is_utc = (lastch == 'z' || lastch == 'Z');
3286 memset(&dt, 0, sizeof(dt));
3291 if (!strncasecmp(datestr, "now", len))
3292 return (int64_t) now * 1000000;
3294 /* parse the year-month-day part */
3295 for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3296 q = small_strptime(p, date_fmt[i], &dt);
3302 /* if the year-month-day part is missing, then take the
3303 * current year-month-day time */
3308 dt = *localtime(&now);
3310 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3315 if (*p == 'T' || *p == 't' || *p == ' ')
3318 /* parse the hour-minute-second part */
3319 for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3320 q = small_strptime(p, time_fmt[i], &dt);
3326 /* parse datestr as a duration */
3331 /* parse datestr as HH:MM:SS */
3332 q = small_strptime(p, time_fmt[0], &dt);
3334 /* parse datestr as S+ */
3335 dt.tm_sec = strtol(p, (char **)&q, 10);
3337 /* the parsing didn't succeed */
3344 /* Now we have all the fields that we can get */
3350 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3352 dt.tm_isdst = -1; /* unknown */
3362 /* parse the .m... part */
3366 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3369 val += n * (*q - '0');
3373 return negative ? -t : t;
3376 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3386 while (*p != '\0' && *p != '=' && *p != '&') {
3387 if ((q - tag) < sizeof(tag) - 1)
3395 while (*p != '&' && *p != '\0') {
3396 if ((q - arg) < arg_size - 1) {
3406 if (!strcmp(tag, tag1))
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 //FIXME needs to know the time_base
3510 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3513 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3514 PRINT("stream #%d:\n", pkt->stream_index);
3515 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3516 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3517 /* DTS is _always_ valid after av_read_frame() */
3519 if (pkt->dts == AV_NOPTS_VALUE)
3522 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3523 /* PTS may not be known if B-frames are present. */
3525 if (pkt->pts == AV_NOPTS_VALUE)
3528 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3530 PRINT(" size=%d\n", pkt->size);
3533 av_hex_dump(f, pkt->data, pkt->size);
3536 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3538 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3541 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3543 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3546 #if FF_API_URL_SPLIT
3547 attribute_deprecated
3548 void ff_url_split(char *proto, int proto_size,
3549 char *authorization, int authorization_size,
3550 char *hostname, int hostname_size,
3552 char *path, int path_size,
3555 av_url_split(proto, proto_size,
3556 authorization, authorization_size,
3557 hostname, hostname_size,
3564 void av_url_split(char *proto, int proto_size,
3565 char *authorization, int authorization_size,
3566 char *hostname, int hostname_size,
3568 char *path, int path_size,
3571 const char *p, *ls, *at, *col, *brk;
3573 if (port_ptr) *port_ptr = -1;
3574 if (proto_size > 0) proto[0] = 0;
3575 if (authorization_size > 0) authorization[0] = 0;
3576 if (hostname_size > 0) hostname[0] = 0;
3577 if (path_size > 0) path[0] = 0;
3579 /* parse protocol */
3580 if ((p = strchr(url, ':'))) {
3581 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3586 /* no protocol means plain filename */
3587 av_strlcpy(path, url, path_size);
3591 /* separate path from hostname */
3592 ls = strchr(p, '/');
3594 ls = strchr(p, '?');
3596 av_strlcpy(path, ls, path_size);
3598 ls = &p[strlen(p)]; // XXX
3600 /* the rest is hostname, use that to parse auth/port */
3602 /* authorization (user[:pass]@hostname) */
3603 if ((at = strchr(p, '@')) && at < ls) {
3604 av_strlcpy(authorization, p,
3605 FFMIN(authorization_size, at + 1 - p));
3606 p = at + 1; /* skip '@' */
3609 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3611 av_strlcpy(hostname, p + 1,
3612 FFMIN(hostname_size, brk - p));
3613 if (brk[1] == ':' && port_ptr)
3614 *port_ptr = atoi(brk + 2);
3615 } else if ((col = strchr(p, ':')) && col < ls) {
3616 av_strlcpy(hostname, p,
3617 FFMIN(col + 1 - p, hostname_size));
3618 if (port_ptr) *port_ptr = atoi(col + 1);
3620 av_strlcpy(hostname, p,
3621 FFMIN(ls + 1 - p, hostname_size));
3625 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3628 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3631 'C', 'D', 'E', 'F' };
3632 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3635 'c', 'd', 'e', 'f' };
3636 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3638 for(i = 0; i < s; i++) {
3639 buff[i * 2] = hex_table[src[i] >> 4];
3640 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3646 int ff_hex_to_data(uint8_t *data, const char *p)
3653 p += strspn(p, SPACE_CHARS);
3656 c = toupper((unsigned char) *p++);
3657 if (c >= '0' && c <= '9')
3659 else if (c >= 'A' && c <= 'F')
3674 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3675 unsigned int pts_num, unsigned int pts_den)
3677 s->pts_wrap_bits = pts_wrap_bits;
3679 if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3680 if(s->time_base.num != pts_num)
3681 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3683 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3685 if(!s->time_base.num || !s->time_base.den)
3686 s->time_base.num= s->time_base.den= 0;
3689 int ff_url_join(char *str, int size, const char *proto,
3690 const char *authorization, const char *hostname,
3691 int port, const char *fmt, ...)
3694 struct addrinfo hints, *ai;
3699 av_strlcatf(str, size, "%s://", proto);
3700 if (authorization && authorization[0])
3701 av_strlcatf(str, size, "%s@", authorization);
3702 #if CONFIG_NETWORK && defined(AF_INET6)
3703 /* Determine if hostname is a numerical IPv6 address,
3704 * properly escape it within [] in that case. */
3705 memset(&hints, 0, sizeof(hints));
3706 hints.ai_flags = AI_NUMERICHOST;
3707 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3708 if (ai->ai_family == AF_INET6) {
3709 av_strlcat(str, "[", size);
3710 av_strlcat(str, hostname, size);
3711 av_strlcat(str, "]", size);
3713 av_strlcat(str, hostname, size);
3718 /* Not an IPv6 address, just output the plain string. */
3719 av_strlcat(str, hostname, size);
3722 av_strlcatf(str, size, ":%d", port);
3725 int len = strlen(str);
3728 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3734 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3735 AVFormatContext *src)
3740 local_pkt.stream_index = dst_stream;
3741 if (pkt->pts != AV_NOPTS_VALUE)
3742 local_pkt.pts = av_rescale_q(pkt->pts,
3743 src->streams[pkt->stream_index]->time_base,
3744 dst->streams[dst_stream]->time_base);
3745 if (pkt->dts != AV_NOPTS_VALUE)
3746 local_pkt.dts = av_rescale_q(pkt->dts,
3747 src->streams[pkt->stream_index]->time_base,
3748 dst->streams[dst_stream]->time_base);
3749 return av_write_frame(dst, &local_pkt);
3752 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3755 const char *ptr = str;
3757 /* Parse key=value pairs. */
3760 char *dest = NULL, *dest_end;
3761 int key_len, dest_len = 0;
3763 /* Skip whitespace and potential commas. */
3764 while (*ptr && (isspace(*ptr) || *ptr == ','))
3771 if (!(ptr = strchr(key, '=')))
3774 key_len = ptr - key;
3776 callback_get_buf(context, key, key_len, &dest, &dest_len);
3777 dest_end = dest + dest_len - 1;
3781 while (*ptr && *ptr != '\"') {
3785 if (dest && dest < dest_end)
3789 if (dest && dest < dest_end)
3797 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3798 if (dest && dest < dest_end)