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 "libavcodec/opt.h"
26 #include "libavutil/avstring.h"
28 #include "audiointerleave.h"
42 * various utility functions for use within FFmpeg
45 unsigned avformat_version(void)
47 return LIBAVFORMAT_VERSION_INT;
50 const char *avformat_configuration(void)
52 return FFMPEG_CONFIGURATION;
55 const char *avformat_license(void)
57 #define LICENSE_PREFIX "libavformat license: "
58 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
61 /* fraction handling */
64 * f = val + (num / den) + 0.5.
66 * 'num' is normalized so that it is such as 0 <= num < den.
68 * @param f fractional number
69 * @param val integer value
70 * @param num must be >= 0
71 * @param den must be >= 1
73 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
86 * Fractional addition to f: f = f + (incr / f->den).
88 * @param f fractional number
89 * @param incr increment, can be positive or negative
91 static void av_frac_add(AVFrac *f, int64_t incr)
104 } else if (num >= den) {
111 /** head of registered input format linked list */
112 AVInputFormat *first_iformat = NULL;
113 /** head of registered output format linked list */
114 AVOutputFormat *first_oformat = NULL;
116 AVInputFormat *av_iformat_next(AVInputFormat *f)
118 if(f) return f->next;
119 else return first_iformat;
122 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
124 if(f) return f->next;
125 else return first_oformat;
128 void av_register_input_format(AVInputFormat *format)
132 while (*p != NULL) p = &(*p)->next;
137 void av_register_output_format(AVOutputFormat *format)
141 while (*p != NULL) p = &(*p)->next;
146 int av_match_ext(const char *filename, const char *extensions)
154 ext = strrchr(filename, '.');
160 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
163 if (!strcasecmp(ext1, ext))
173 static int match_format(const char *name, const char *names)
181 namelen = strlen(name);
182 while ((p = strchr(names, ','))) {
183 len = FFMAX(p - names, namelen);
184 if (!strncasecmp(name, names, len))
188 return !strcasecmp(name, names);
191 #if LIBAVFORMAT_VERSION_MAJOR < 53
192 AVOutputFormat *guess_format(const char *short_name, const char *filename,
193 const char *mime_type)
195 return av_guess_format(short_name, filename, mime_type);
199 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
200 const char *mime_type)
202 AVOutputFormat *fmt, *fmt_found;
203 int score_max, score;
205 /* specific test for image sequences */
206 #if CONFIG_IMAGE2_MUXER
207 if (!short_name && filename &&
208 av_filename_number_test(filename) &&
209 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
210 return av_guess_format("image2", NULL, NULL);
213 /* Find the proper file type. */
217 while (fmt != NULL) {
219 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
221 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
223 if (filename && fmt->extensions &&
224 av_match_ext(filename, fmt->extensions)) {
227 if (score > score_max) {
236 #if LIBAVFORMAT_VERSION_MAJOR < 53
237 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
238 const char *mime_type)
240 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
243 AVOutputFormat *stream_fmt;
244 char stream_format_name[64];
246 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
247 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
257 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
258 const char *filename, const char *mime_type, enum AVMediaType type){
259 if(type == AVMEDIA_TYPE_VIDEO){
260 enum CodecID codec_id= CODEC_ID_NONE;
262 #if CONFIG_IMAGE2_MUXER
263 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
264 codec_id= av_guess_image2_codec(filename);
267 if(codec_id == CODEC_ID_NONE)
268 codec_id= fmt->video_codec;
270 }else if(type == AVMEDIA_TYPE_AUDIO)
271 return fmt->audio_codec;
273 return CODEC_ID_NONE;
276 AVInputFormat *av_find_input_format(const char *short_name)
279 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
280 if (match_format(short_name, fmt->name))
286 #if LIBAVFORMAT_VERSION_MAJOR < 53 && CONFIG_SHARED && HAVE_SYMVER
287 FF_SYMVER(void, av_destruct_packet_nofree, (AVPacket *pkt), "LIBAVFORMAT_52")
289 av_destruct_packet_nofree(pkt);
292 FF_SYMVER(void, av_destruct_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
294 av_destruct_packet(pkt);
297 FF_SYMVER(int, av_new_packet, (AVPacket *pkt, int size), "LIBAVFORMAT_52")
299 return av_new_packet(pkt, size);
302 FF_SYMVER(int, av_dup_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
304 return av_dup_packet(pkt);
307 FF_SYMVER(void, av_free_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
312 FF_SYMVER(void, av_init_packet, (AVPacket *pkt), "LIBAVFORMAT_52")
314 av_log(NULL, AV_LOG_WARNING, "Diverting av_*_packet function calls to libavcodec. Recompile to improve performance\n");
319 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
321 int ret= av_new_packet(pkt, size);
326 pkt->pos= url_ftell(s);
328 ret= get_buffer(s, pkt->data, size);
332 av_shrink_packet(pkt, ret);
338 int av_filename_number_test(const char *filename)
341 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
344 AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
346 AVInputFormat *fmt1, *fmt;
350 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
351 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
354 if (fmt1->read_probe) {
355 score = fmt1->read_probe(pd);
356 } else if (fmt1->extensions) {
357 if (av_match_ext(pd->filename, fmt1->extensions)) {
361 if (score > *score_max) {
364 }else if (score == *score_max)
370 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
372 return av_probe_input_format2(pd, is_opened, &score);
375 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
377 static const struct {
378 const char *name; enum CodecID id; enum AVMediaType type;
380 { "aac" , CODEC_ID_AAC , AVMEDIA_TYPE_AUDIO },
381 { "ac3" , CODEC_ID_AC3 , AVMEDIA_TYPE_AUDIO },
382 { "dts" , CODEC_ID_DTS , AVMEDIA_TYPE_AUDIO },
383 { "eac3" , CODEC_ID_EAC3 , AVMEDIA_TYPE_AUDIO },
384 { "h264" , CODEC_ID_H264 , AVMEDIA_TYPE_VIDEO },
385 { "m4v" , CODEC_ID_MPEG4 , AVMEDIA_TYPE_VIDEO },
386 { "mp3" , CODEC_ID_MP3 , AVMEDIA_TYPE_AUDIO },
387 { "mpegvideo", CODEC_ID_MPEG2VIDEO, AVMEDIA_TYPE_VIDEO },
390 AVInputFormat *fmt = av_probe_input_format2(pd, 1, &score);
394 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
395 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
396 for (i = 0; fmt_id_type[i].name; i++) {
397 if (!strcmp(fmt->name, fmt_id_type[i].name)) {
398 st->codec->codec_id = fmt_id_type[i].id;
399 st->codec->codec_type = fmt_id_type[i].type;
407 /************************************************************/
408 /* input media file */
411 * Open a media file from an IO stream. 'fmt' must be specified.
413 int av_open_input_stream(AVFormatContext **ic_ptr,
414 ByteIOContext *pb, const char *filename,
415 AVInputFormat *fmt, AVFormatParameters *ap)
419 AVFormatParameters default_ap;
423 memset(ap, 0, sizeof(default_ap));
426 if(!ap->prealloced_context)
427 ic = avformat_alloc_context();
431 err = AVERROR(ENOMEM);
436 ic->duration = AV_NOPTS_VALUE;
437 ic->start_time = AV_NOPTS_VALUE;
438 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
440 /* allocate private data */
441 if (fmt->priv_data_size > 0) {
442 ic->priv_data = av_mallocz(fmt->priv_data_size);
443 if (!ic->priv_data) {
444 err = AVERROR(ENOMEM);
448 ic->priv_data = NULL;
451 if (ic->iformat->read_header) {
452 err = ic->iformat->read_header(ic, ap);
457 if (pb && !ic->data_offset)
458 ic->data_offset = url_ftell(ic->pb);
460 #if FF_API_OLD_METADATA
461 ff_metadata_demux_compat(ic);
464 ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
471 av_freep(&ic->priv_data);
472 for(i=0;i<ic->nb_streams;i++) {
473 AVStream *st = ic->streams[i];
475 av_free(st->priv_data);
476 av_free(st->codec->extradata);
487 /** size of probe buffer, for guessing file type from file contents */
488 #define PROBE_BUF_MIN 2048
489 #define PROBE_BUF_MAX (1<<20)
491 int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
492 const char *filename, void *logctx,
493 unsigned int offset, unsigned int max_probe_size)
495 AVProbeData pd = { filename ? filename : "", NULL, -offset };
496 unsigned char *buf = NULL;
497 int ret = 0, probe_size;
499 if (!max_probe_size) {
500 max_probe_size = PROBE_BUF_MAX;
501 } else if (max_probe_size > PROBE_BUF_MAX) {
502 max_probe_size = PROBE_BUF_MAX;
503 } else if (max_probe_size < PROBE_BUF_MIN) {
504 return AVERROR(EINVAL);
507 if (offset >= max_probe_size) {
508 return AVERROR(EINVAL);
511 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
512 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
513 int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
514 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
516 if (probe_size < offset) {
520 /* read probe data */
521 buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
522 if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
523 /* fail if error was not end of file, otherwise, lower score */
524 if (ret != AVERROR_EOF) {
529 ret = 0; /* error was end of file, nothing read */
532 pd.buf = &buf[offset];
534 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
536 /* guess file format */
537 *fmt = av_probe_input_format2(&pd, 1, &score);
539 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
540 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
542 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
548 return AVERROR_INVALIDDATA;
551 /* rewind. reuse probe buffer to avoid seeking */
552 if ((ret = ff_rewind_with_probe_data(*pb, buf, pd.buf_size)) < 0)
558 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
561 AVFormatParameters *ap)
564 AVProbeData probe_data, *pd = &probe_data;
565 ByteIOContext *pb = NULL;
566 void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
570 pd->filename = filename;
575 /* guess format if no file can be opened */
576 fmt = av_probe_input_format(pd, 0);
579 /* Do not open file if the format does not need it. XXX: specific
580 hack needed to handle RTSP/TCP */
581 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
582 /* if no file needed do not try to open one */
583 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
587 url_setbufsize(pb, buf_size);
589 if (!fmt && (err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
594 /* if still no format found, error */
596 err = AVERROR_INVALIDDATA;
600 /* check filename in case an image number is expected */
601 if (fmt->flags & AVFMT_NEEDNUMBER) {
602 if (!av_filename_number_test(filename)) {
603 err = AVERROR_NUMEXPECTED;
607 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
615 if (ap && ap->prealloced_context)
622 /*******************************************************/
624 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
625 AVPacketList **plast_pktl){
626 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
631 (*plast_pktl)->next = pktl;
633 *packet_buffer = pktl;
635 /* add the packet in the buffered packet list */
641 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
647 AVPacketList *pktl = s->raw_packet_buffer;
651 if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
652 !s->streams[pkt->stream_index]->probe_packets ||
653 s->raw_packet_buffer_remaining_size < pkt->size){
654 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
657 s->raw_packet_buffer = pktl->next;
658 s->raw_packet_buffer_remaining_size += pkt->size;
665 ret= s->iformat->read_packet(s, pkt);
667 if (!pktl || ret == AVERROR(EAGAIN))
669 for (i = 0; i < s->nb_streams; i++)
670 s->streams[i]->probe_packets = 0;
673 st= s->streams[pkt->stream_index];
675 switch(st->codec->codec_type){
676 case AVMEDIA_TYPE_VIDEO:
677 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
679 case AVMEDIA_TYPE_AUDIO:
680 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
682 case AVMEDIA_TYPE_SUBTITLE:
683 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
687 if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
691 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
692 s->raw_packet_buffer_remaining_size -= pkt->size;
694 if(st->codec->codec_id == CODEC_ID_PROBE){
695 AVProbeData *pd = &st->probe_data;
696 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
699 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
700 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
701 pd->buf_size += pkt->size;
702 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
704 if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
705 //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
706 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
707 if(st->codec->codec_id != CODEC_ID_PROBE){
710 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
717 /**********************************************************/
720 * Get the number of samples of an audio frame. Return -1 on error.
722 static int get_audio_frame_size(AVCodecContext *enc, int size)
726 if(enc->codec_id == CODEC_ID_VORBIS)
729 if (enc->frame_size <= 1) {
730 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
732 if (bits_per_sample) {
733 if (enc->channels == 0)
735 frame_size = (size << 3) / (bits_per_sample * enc->channels);
737 /* used for example by ADPCM codecs */
738 if (enc->bit_rate == 0)
740 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
743 frame_size = enc->frame_size;
750 * Return the frame duration in seconds. Return 0 if not available.
752 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
753 AVCodecParserContext *pc, AVPacket *pkt)
759 switch(st->codec->codec_type) {
760 case AVMEDIA_TYPE_VIDEO:
761 if(st->time_base.num*1000LL > st->time_base.den){
762 *pnum = st->time_base.num;
763 *pden = st->time_base.den;
764 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
765 *pnum = st->codec->time_base.num;
766 *pden = st->codec->time_base.den;
767 if (pc && pc->repeat_pict) {
768 *pnum = (*pnum) * (1 + pc->repeat_pict);
770 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
771 //Thus if we have no parser in such case leave duration undefined.
772 if(st->codec->ticks_per_frame>1 && !pc){
777 case AVMEDIA_TYPE_AUDIO:
778 frame_size = get_audio_frame_size(st->codec, pkt->size);
782 *pden = st->codec->sample_rate;
789 static int is_intra_only(AVCodecContext *enc){
790 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
792 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
793 switch(enc->codec_id){
795 case CODEC_ID_MJPEGB:
797 case CODEC_ID_RAWVIDEO:
798 case CODEC_ID_DVVIDEO:
799 case CODEC_ID_HUFFYUV:
800 case CODEC_ID_FFVHUFF:
805 case CODEC_ID_JPEG2000:
813 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
814 int64_t dts, int64_t pts)
816 AVStream *st= s->streams[stream_index];
817 AVPacketList *pktl= s->packet_buffer;
819 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
822 st->first_dts= dts - st->cur_dts;
825 for(; pktl; pktl= pktl->next){
826 if(pktl->pkt.stream_index != stream_index)
828 //FIXME think more about this check
829 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
830 pktl->pkt.pts += st->first_dts;
832 if(pktl->pkt.dts != AV_NOPTS_VALUE)
833 pktl->pkt.dts += st->first_dts;
835 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
836 st->start_time= pktl->pkt.pts;
838 if (st->start_time == AV_NOPTS_VALUE)
839 st->start_time = pts;
842 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
844 AVPacketList *pktl= s->packet_buffer;
847 if(st->first_dts != AV_NOPTS_VALUE){
848 cur_dts= st->first_dts;
849 for(; pktl; pktl= pktl->next){
850 if(pktl->pkt.stream_index == pkt->stream_index){
851 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
853 cur_dts -= pkt->duration;
856 pktl= s->packet_buffer;
857 st->first_dts = cur_dts;
858 }else if(st->cur_dts)
861 for(; pktl; pktl= pktl->next){
862 if(pktl->pkt.stream_index != pkt->stream_index)
864 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
865 && !pktl->pkt.duration){
866 pktl->pkt.dts= cur_dts;
867 if(!st->codec->has_b_frames)
868 pktl->pkt.pts= cur_dts;
869 cur_dts += pkt->duration;
870 pktl->pkt.duration= pkt->duration;
874 if(st->first_dts == AV_NOPTS_VALUE)
875 st->cur_dts= cur_dts;
878 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
879 AVCodecParserContext *pc, AVPacket *pkt)
881 int num, den, presentation_delayed, delay, i;
884 if (s->flags & AVFMT_FLAG_NOFILLIN)
887 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
888 pkt->dts= AV_NOPTS_VALUE;
890 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
891 //FIXME Set low_delay = 0 when has_b_frames = 1
892 st->codec->has_b_frames = 1;
894 /* do we have a video B-frame ? */
895 delay= st->codec->has_b_frames;
896 presentation_delayed = 0;
897 /* XXX: need has_b_frame, but cannot get it if the codec is
900 pc && pc->pict_type != FF_B_TYPE)
901 presentation_delayed = 1;
903 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
904 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
905 pkt->dts -= 1LL<<st->pts_wrap_bits;
908 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
909 // we take the conservative approach and discard both
910 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
911 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
912 av_log(s, AV_LOG_DEBUG, "invalid dts/pts combination\n");
913 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
916 if (pkt->duration == 0) {
917 compute_frame_duration(&num, &den, st, pc, pkt);
919 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
921 if(pkt->duration != 0 && s->packet_buffer)
922 update_initial_durations(s, st, pkt);
926 /* correct timestamps with byte offset if demuxers only have timestamps
927 on packet boundaries */
928 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
929 /* this will estimate bitrate based on this frame's duration and size */
930 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
931 if(pkt->pts != AV_NOPTS_VALUE)
933 if(pkt->dts != AV_NOPTS_VALUE)
937 if (pc && pc->dts_sync_point >= 0) {
938 // we have synchronization info from the parser
939 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
941 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
942 if (pkt->dts != AV_NOPTS_VALUE) {
943 // got DTS from the stream, update reference timestamp
944 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
945 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
946 } else if (st->reference_dts != AV_NOPTS_VALUE) {
947 // compute DTS based on reference timestamp
948 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
949 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
951 if (pc->dts_sync_point > 0)
952 st->reference_dts = pkt->dts; // new reference
956 /* This may be redundant, but it should not hurt. */
957 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
958 presentation_delayed = 1;
960 // 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);
961 /* interpolate PTS and DTS if they are not present */
962 //We skip H264 currently because delay and has_b_frames are not reliably set
963 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
964 if (presentation_delayed) {
965 /* DTS = decompression timestamp */
966 /* PTS = presentation timestamp */
967 if (pkt->dts == AV_NOPTS_VALUE)
968 pkt->dts = st->last_IP_pts;
969 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
970 if (pkt->dts == AV_NOPTS_VALUE)
971 pkt->dts = st->cur_dts;
973 /* this is tricky: the dts must be incremented by the duration
974 of the frame we are displaying, i.e. the last I- or P-frame */
975 if (st->last_IP_duration == 0)
976 st->last_IP_duration = pkt->duration;
977 if(pkt->dts != AV_NOPTS_VALUE)
978 st->cur_dts = pkt->dts + st->last_IP_duration;
979 st->last_IP_duration = pkt->duration;
980 st->last_IP_pts= pkt->pts;
981 /* cannot compute PTS if not present (we can compute it only
982 by knowing the future */
983 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
984 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
985 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
986 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
987 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
988 pkt->pts += pkt->duration;
989 // 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);
993 /* presentation is not delayed : PTS and DTS are the same */
994 if(pkt->pts == AV_NOPTS_VALUE)
996 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
997 if(pkt->pts == AV_NOPTS_VALUE)
998 pkt->pts = st->cur_dts;
1000 if(pkt->pts != AV_NOPTS_VALUE)
1001 st->cur_dts = pkt->pts + pkt->duration;
1005 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
1006 st->pts_buffer[0]= pkt->pts;
1007 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
1008 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
1009 if(pkt->dts == AV_NOPTS_VALUE)
1010 pkt->dts= st->pts_buffer[0];
1011 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
1012 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
1014 if(pkt->dts > st->cur_dts)
1015 st->cur_dts = pkt->dts;
1018 // 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);
1021 if(is_intra_only(st->codec))
1022 pkt->flags |= AV_PKT_FLAG_KEY;
1025 /* keyframe computation */
1026 if (pc->key_frame == 1)
1027 pkt->flags |= AV_PKT_FLAG_KEY;
1028 else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1029 pkt->flags |= AV_PKT_FLAG_KEY;
1032 pkt->convergence_duration = pc->convergence_duration;
1036 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1041 av_init_packet(pkt);
1044 /* select current input stream component */
1047 if (!st->need_parsing || !st->parser) {
1048 /* no parsing needed: we just output the packet as is */
1049 /* raw data support */
1050 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1051 compute_pkt_fields(s, st, NULL, pkt);
1053 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1054 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1055 ff_reduce_index(s, st->index);
1056 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1059 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1060 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1061 st->cur_ptr, st->cur_len,
1062 st->cur_pkt.pts, st->cur_pkt.dts,
1064 st->cur_pkt.pts = AV_NOPTS_VALUE;
1065 st->cur_pkt.dts = AV_NOPTS_VALUE;
1066 /* increment read pointer */
1070 /* return packet if any */
1074 pkt->stream_index = st->index;
1075 pkt->pts = st->parser->pts;
1076 pkt->dts = st->parser->dts;
1077 pkt->pos = st->parser->pos;
1078 if(pkt->data == st->cur_pkt.data && pkt->size == st->cur_pkt.size){
1080 pkt->destruct= st->cur_pkt.destruct;
1081 st->cur_pkt.destruct= NULL;
1082 st->cur_pkt.data = NULL;
1083 assert(st->cur_len == 0);
1085 pkt->destruct = NULL;
1087 compute_pkt_fields(s, st, st->parser, pkt);
1089 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1090 ff_reduce_index(s, st->index);
1091 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1092 0, 0, AVINDEX_KEYFRAME);
1099 av_free_packet(&st->cur_pkt);
1104 /* read next packet */
1105 ret = av_read_packet(s, &cur_pkt);
1107 if (ret == AVERROR(EAGAIN))
1109 /* return the last frames, if any */
1110 for(i = 0; i < s->nb_streams; i++) {
1112 if (st->parser && st->need_parsing) {
1113 av_parser_parse2(st->parser, st->codec,
1114 &pkt->data, &pkt->size,
1116 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1122 /* no more packets: really terminate parsing */
1125 st = s->streams[cur_pkt.stream_index];
1126 st->cur_pkt= cur_pkt;
1128 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1129 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1130 st->cur_pkt.pts < st->cur_pkt.dts){
1131 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1132 st->cur_pkt.stream_index,
1136 // av_free_packet(&st->cur_pkt);
1140 if(s->debug & FF_FDEBUG_TS)
1141 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1142 st->cur_pkt.stream_index,
1146 st->cur_pkt.duration,
1150 st->cur_ptr = st->cur_pkt.data;
1151 st->cur_len = st->cur_pkt.size;
1152 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1153 st->parser = av_parser_init(st->codec->codec_id);
1155 /* no parser available: just output the raw packets */
1156 st->need_parsing = AVSTREAM_PARSE_NONE;
1157 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1158 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1159 }else if(st->need_parsing == AVSTREAM_PARSE_FULL_ONCE){
1160 st->parser->flags |= PARSER_FLAG_ONCE;
1162 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1163 st->parser->next_frame_offset=
1164 st->parser->cur_offset= st->cur_pkt.pos;
1169 if(s->debug & FF_FDEBUG_TS)
1170 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1181 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1185 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1188 pktl = s->packet_buffer;
1190 AVPacket *next_pkt= &pktl->pkt;
1192 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1193 int wrap_bits = s->streams[next_pkt->stream_index]->pts_wrap_bits;
1194 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1195 if( pktl->pkt.stream_index == next_pkt->stream_index
1196 && (0 > av_compare_mod(next_pkt->dts, pktl->pkt.dts, 2LL << (wrap_bits - 1)))
1197 && av_compare_mod(pktl->pkt.pts, pktl->pkt.dts, 2LL << (wrap_bits - 1))) { //not b frame
1198 next_pkt->pts= pktl->pkt.dts;
1202 pktl = s->packet_buffer;
1205 if( next_pkt->pts != AV_NOPTS_VALUE
1206 || next_pkt->dts == AV_NOPTS_VALUE
1208 /* read packet from packet buffer, if there is data */
1210 s->packet_buffer = pktl->next;
1216 int ret= av_read_frame_internal(s, pkt);
1218 if(pktl && ret != AVERROR(EAGAIN)){
1225 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1226 &s->packet_buffer_end)) < 0)
1227 return AVERROR(ENOMEM);
1229 assert(!s->packet_buffer);
1230 return av_read_frame_internal(s, pkt);
1235 /* XXX: suppress the packet queue */
1236 static void flush_packet_queue(AVFormatContext *s)
1241 pktl = s->packet_buffer;
1244 s->packet_buffer = pktl->next;
1245 av_free_packet(&pktl->pkt);
1248 while(s->raw_packet_buffer){
1249 pktl = s->raw_packet_buffer;
1250 s->raw_packet_buffer = pktl->next;
1251 av_free_packet(&pktl->pkt);
1254 s->packet_buffer_end=
1255 s->raw_packet_buffer_end= NULL;
1256 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1259 /*******************************************************/
1262 int av_find_default_stream_index(AVFormatContext *s)
1264 int first_audio_index = -1;
1268 if (s->nb_streams <= 0)
1270 for(i = 0; i < s->nb_streams; i++) {
1272 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1275 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1276 first_audio_index = i;
1278 return first_audio_index >= 0 ? first_audio_index : 0;
1282 * Flush the frame reader.
1284 void ff_read_frame_flush(AVFormatContext *s)
1289 flush_packet_queue(s);
1293 /* for each stream, reset read state */
1294 for(i = 0; i < s->nb_streams; i++) {
1298 av_parser_close(st->parser);
1300 av_free_packet(&st->cur_pkt);
1302 st->last_IP_pts = AV_NOPTS_VALUE;
1303 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1304 st->reference_dts = AV_NOPTS_VALUE;
1309 st->probe_packets = MAX_PROBE_PACKETS;
1311 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1312 st->pts_buffer[j]= AV_NOPTS_VALUE;
1316 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1319 for(i = 0; i < s->nb_streams; i++) {
1320 AVStream *st = s->streams[i];
1322 st->cur_dts = av_rescale(timestamp,
1323 st->time_base.den * (int64_t)ref_st->time_base.num,
1324 st->time_base.num * (int64_t)ref_st->time_base.den);
1328 void ff_reduce_index(AVFormatContext *s, int stream_index)
1330 AVStream *st= s->streams[stream_index];
1331 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1333 if((unsigned)st->nb_index_entries >= max_entries){
1335 for(i=0; 2*i<st->nb_index_entries; i++)
1336 st->index_entries[i]= st->index_entries[2*i];
1337 st->nb_index_entries= i;
1341 int av_add_index_entry(AVStream *st,
1342 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1344 AVIndexEntry *entries, *ie;
1347 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1350 entries = av_fast_realloc(st->index_entries,
1351 &st->index_entries_allocated_size,
1352 (st->nb_index_entries + 1) *
1353 sizeof(AVIndexEntry));
1357 st->index_entries= entries;
1359 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1362 index= st->nb_index_entries++;
1363 ie= &entries[index];
1364 assert(index==0 || ie[-1].timestamp < timestamp);
1366 ie= &entries[index];
1367 if(ie->timestamp != timestamp){
1368 if(ie->timestamp <= timestamp)
1370 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1371 st->nb_index_entries++;
1372 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1373 distance= ie->min_distance;
1377 ie->timestamp = timestamp;
1378 ie->min_distance= distance;
1385 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1388 AVIndexEntry *entries= st->index_entries;
1389 int nb_entries= st->nb_index_entries;
1396 //optimize appending index entries at the end
1397 if(b && entries[b-1].timestamp < wanted_timestamp)
1402 timestamp = entries[m].timestamp;
1403 if(timestamp >= wanted_timestamp)
1405 if(timestamp <= wanted_timestamp)
1408 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1410 if(!(flags & AVSEEK_FLAG_ANY)){
1411 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1412 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1423 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1424 AVInputFormat *avif= s->iformat;
1425 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1426 int64_t ts_min, ts_max, ts;
1431 if (stream_index < 0)
1435 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1439 ts_min= AV_NOPTS_VALUE;
1440 pos_limit= -1; //gcc falsely says it may be uninitialized
1442 st= s->streams[stream_index];
1443 if(st->index_entries){
1446 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()
1447 index= FFMAX(index, 0);
1448 e= &st->index_entries[index];
1450 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1452 ts_min= e->timestamp;
1454 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1461 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1462 assert(index < st->nb_index_entries);
1464 e= &st->index_entries[index];
1465 assert(e->timestamp >= target_ts);
1467 ts_max= e->timestamp;
1468 pos_limit= pos_max - e->min_distance;
1470 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1471 pos_max,pos_limit, ts_max);
1476 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1481 if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1484 av_update_cur_dts(s, st, ts);
1489 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 )){
1491 int64_t start_pos, filesize;
1495 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1498 if(ts_min == AV_NOPTS_VALUE){
1499 pos_min = s->data_offset;
1500 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1501 if (ts_min == AV_NOPTS_VALUE)
1505 if(ts_max == AV_NOPTS_VALUE){
1507 filesize = url_fsize(s->pb);
1508 pos_max = filesize - 1;
1511 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1513 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1514 if (ts_max == AV_NOPTS_VALUE)
1518 int64_t tmp_pos= pos_max + 1;
1519 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1520 if(tmp_ts == AV_NOPTS_VALUE)
1524 if(tmp_pos >= filesize)
1530 if(ts_min > ts_max){
1532 }else if(ts_min == ts_max){
1537 while (pos_min < pos_limit) {
1539 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1543 assert(pos_limit <= pos_max);
1546 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1547 // interpolate position (better than dichotomy)
1548 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1549 + pos_min - approximate_keyframe_distance;
1550 }else if(no_change==1){
1551 // bisection, if interpolation failed to change min or max pos last time
1552 pos = (pos_min + pos_limit)>>1;
1554 /* linear search if bisection failed, can only happen if there
1555 are very few or no keyframes between min/max */
1560 else if(pos > pos_limit)
1564 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1570 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1571 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1572 start_pos, no_change);
1574 if(ts == AV_NOPTS_VALUE){
1575 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1578 assert(ts != AV_NOPTS_VALUE);
1579 if (target_ts <= ts) {
1580 pos_limit = start_pos - 1;
1584 if (target_ts >= ts) {
1590 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1591 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1594 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1596 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1597 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1598 pos, ts_min, target_ts, ts_max);
1604 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1605 int64_t pos_min, pos_max;
1609 if (stream_index < 0)
1612 st= s->streams[stream_index];
1615 pos_min = s->data_offset;
1616 pos_max = url_fsize(s->pb) - 1;
1618 if (pos < pos_min) pos= pos_min;
1619 else if(pos > pos_max) pos= pos_max;
1621 url_fseek(s->pb, pos, SEEK_SET);
1624 av_update_cur_dts(s, st, ts);
1629 static int av_seek_frame_generic(AVFormatContext *s,
1630 int stream_index, int64_t timestamp, int flags)
1637 st = s->streams[stream_index];
1639 index = av_index_search_timestamp(st, timestamp, flags);
1641 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1644 if(index < 0 || index==st->nb_index_entries-1){
1648 if(st->nb_index_entries){
1649 assert(st->index_entries);
1650 ie= &st->index_entries[st->nb_index_entries-1];
1651 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1653 av_update_cur_dts(s, st, ie->timestamp);
1655 if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1661 ret = av_read_frame(s, &pkt);
1662 }while(ret == AVERROR(EAGAIN));
1665 av_free_packet(&pkt);
1666 if(stream_index == pkt.stream_index){
1667 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1671 index = av_index_search_timestamp(st, timestamp, flags);
1676 ff_read_frame_flush(s);
1677 if (s->iformat->read_seek){
1678 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1681 ie = &st->index_entries[index];
1682 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1684 av_update_cur_dts(s, st, ie->timestamp);
1689 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1694 ff_read_frame_flush(s);
1696 if(flags & AVSEEK_FLAG_BYTE)
1697 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1699 if(stream_index < 0){
1700 stream_index= av_find_default_stream_index(s);
1701 if(stream_index < 0)
1704 st= s->streams[stream_index];
1705 /* timestamp for default must be expressed in AV_TIME_BASE units */
1706 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1709 /* first, we try the format specific seek */
1710 if (s->iformat->read_seek)
1711 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1718 if(s->iformat->read_timestamp)
1719 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1721 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1724 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1726 if(min_ts > ts || max_ts < ts)
1729 ff_read_frame_flush(s);
1731 if (s->iformat->read_seek2)
1732 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1734 if(s->iformat->read_timestamp){
1735 //try to seek via read_timestamp()
1738 //Fallback to old API if new is not implemented but old is
1739 //Note the old has somewat different sematics
1740 if(s->iformat->read_seek || 1)
1741 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1743 // try some generic seek like av_seek_frame_generic() but with new ts semantics
1746 /*******************************************************/
1749 * Return TRUE if the stream has accurate duration in any stream.
1751 * @return TRUE if the stream has accurate duration for at least one component.
1753 static int av_has_duration(AVFormatContext *ic)
1758 for(i = 0;i < ic->nb_streams; i++) {
1759 st = ic->streams[i];
1760 if (st->duration != AV_NOPTS_VALUE)
1767 * Estimate the stream timings from the one of each components.
1769 * Also computes the global bitrate if possible.
1771 static void av_update_stream_timings(AVFormatContext *ic)
1773 int64_t start_time, start_time1, end_time, end_time1;
1774 int64_t duration, duration1;
1778 start_time = INT64_MAX;
1779 end_time = INT64_MIN;
1780 duration = INT64_MIN;
1781 for(i = 0;i < ic->nb_streams; i++) {
1782 st = ic->streams[i];
1783 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1784 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1785 if (start_time1 < start_time)
1786 start_time = start_time1;
1787 if (st->duration != AV_NOPTS_VALUE) {
1788 end_time1 = start_time1
1789 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1790 if (end_time1 > end_time)
1791 end_time = end_time1;
1794 if (st->duration != AV_NOPTS_VALUE) {
1795 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1796 if (duration1 > duration)
1797 duration = duration1;
1800 if (start_time != INT64_MAX) {
1801 ic->start_time = start_time;
1802 if (end_time != INT64_MIN) {
1803 if (end_time - start_time > duration)
1804 duration = end_time - start_time;
1807 if (duration != INT64_MIN) {
1808 ic->duration = duration;
1809 if (ic->file_size > 0) {
1810 /* compute the bitrate */
1811 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1812 (double)ic->duration;
1817 static void fill_all_stream_timings(AVFormatContext *ic)
1822 av_update_stream_timings(ic);
1823 for(i = 0;i < ic->nb_streams; i++) {
1824 st = ic->streams[i];
1825 if (st->start_time == AV_NOPTS_VALUE) {
1826 if(ic->start_time != AV_NOPTS_VALUE)
1827 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1828 if(ic->duration != AV_NOPTS_VALUE)
1829 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1834 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1836 int64_t filesize, duration;
1840 /* if bit_rate is already set, we believe it */
1841 if (ic->bit_rate == 0) {
1843 for(i=0;i<ic->nb_streams;i++) {
1844 st = ic->streams[i];
1845 bit_rate += st->codec->bit_rate;
1847 ic->bit_rate = bit_rate;
1850 /* if duration is already set, we believe it */
1851 if (ic->duration == AV_NOPTS_VALUE &&
1852 ic->bit_rate != 0 &&
1853 ic->file_size != 0) {
1854 filesize = ic->file_size;
1856 for(i = 0; i < ic->nb_streams; i++) {
1857 st = ic->streams[i];
1858 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1859 if (st->duration == AV_NOPTS_VALUE)
1860 st->duration = duration;
1866 #define DURATION_MAX_READ_SIZE 250000
1867 #define DURATION_MAX_RETRY 3
1869 /* only usable for MPEG-PS streams */
1870 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1872 AVPacket pkt1, *pkt = &pkt1;
1874 int read_size, i, ret;
1875 int64_t end_time, start_time[MAX_STREAMS];
1876 int64_t filesize, offset, duration;
1881 /* flush packet queue */
1882 flush_packet_queue(ic);
1884 for(i=0;i<ic->nb_streams;i++) {
1885 st = ic->streams[i];
1886 if(st->start_time != AV_NOPTS_VALUE){
1887 start_time[i]= st->start_time;
1888 }else if(st->first_dts != AV_NOPTS_VALUE){
1889 start_time[i]= st->first_dts;
1891 av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1894 av_parser_close(st->parser);
1896 av_free_packet(&st->cur_pkt);
1900 /* estimate the end time (duration) */
1901 /* XXX: may need to support wrapping */
1902 filesize = ic->file_size;
1903 end_time = AV_NOPTS_VALUE;
1905 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1909 url_fseek(ic->pb, offset, SEEK_SET);
1912 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1916 ret = av_read_packet(ic, pkt);
1917 }while(ret == AVERROR(EAGAIN));
1920 read_size += pkt->size;
1921 st = ic->streams[pkt->stream_index];
1922 if (pkt->pts != AV_NOPTS_VALUE &&
1923 start_time[pkt->stream_index] != AV_NOPTS_VALUE) {
1924 end_time = pkt->pts;
1925 duration = end_time - start_time[pkt->stream_index];
1927 duration += 1LL<<st->pts_wrap_bits;
1929 if (st->duration == AV_NOPTS_VALUE ||
1930 st->duration < duration)
1931 st->duration = duration;
1934 av_free_packet(pkt);
1936 }while( end_time==AV_NOPTS_VALUE
1937 && filesize > (DURATION_MAX_READ_SIZE<<retry)
1938 && ++retry <= DURATION_MAX_RETRY);
1940 fill_all_stream_timings(ic);
1942 url_fseek(ic->pb, old_offset, SEEK_SET);
1943 for(i=0; i<ic->nb_streams; i++){
1945 st->cur_dts= st->first_dts;
1946 st->last_IP_pts = AV_NOPTS_VALUE;
1950 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1954 /* get the file size, if possible */
1955 if (ic->iformat->flags & AVFMT_NOFILE) {
1958 file_size = url_fsize(ic->pb);
1962 ic->file_size = file_size;
1964 if ((!strcmp(ic->iformat->name, "mpeg") ||
1965 !strcmp(ic->iformat->name, "mpegts")) &&
1966 file_size && !url_is_streamed(ic->pb)) {
1967 /* get accurate estimate from the PTSes */
1968 av_estimate_timings_from_pts(ic, old_offset);
1969 } else if (av_has_duration(ic)) {
1970 /* at least one component has timings - we use them for all
1972 fill_all_stream_timings(ic);
1974 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1975 /* less precise: use bitrate info */
1976 av_estimate_timings_from_bit_rate(ic);
1978 av_update_stream_timings(ic);
1984 for(i = 0;i < ic->nb_streams; i++) {
1985 st = ic->streams[i];
1986 printf("%d: start_time: %0.3f duration: %0.3f\n",
1987 i, (double)st->start_time / AV_TIME_BASE,
1988 (double)st->duration / AV_TIME_BASE);
1990 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1991 (double)ic->start_time / AV_TIME_BASE,
1992 (double)ic->duration / AV_TIME_BASE,
1993 ic->bit_rate / 1000);
1998 static int has_codec_parameters(AVCodecContext *enc)
2001 switch(enc->codec_type) {
2002 case AVMEDIA_TYPE_AUDIO:
2003 val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
2004 if(!enc->frame_size &&
2005 (enc->codec_id == CODEC_ID_VORBIS ||
2006 enc->codec_id == CODEC_ID_AAC ||
2007 enc->codec_id == CODEC_ID_MP1 ||
2008 enc->codec_id == CODEC_ID_MP2 ||
2009 enc->codec_id == CODEC_ID_MP3 ||
2010 enc->codec_id == CODEC_ID_SPEEX))
2013 case AVMEDIA_TYPE_VIDEO:
2014 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
2020 return enc->codec_id != CODEC_ID_NONE && val != 0;
2023 static int has_decode_delay_been_guessed(AVStream *st)
2025 return st->codec->codec_id != CODEC_ID_H264 ||
2026 st->codec_info_nb_frames >= 4 + st->codec->has_b_frames;
2029 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
2033 int got_picture, data_size, ret=0;
2036 if(!st->codec->codec){
2037 codec = avcodec_find_decoder(st->codec->codec_id);
2040 ret = avcodec_open(st->codec, codec);
2045 if(!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st)){
2046 switch(st->codec->codec_type) {
2047 case AVMEDIA_TYPE_VIDEO:
2048 avcodec_get_frame_defaults(&picture);
2049 ret = avcodec_decode_video2(st->codec, &picture,
2050 &got_picture, avpkt);
2052 case AVMEDIA_TYPE_AUDIO:
2053 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2054 samples = av_malloc(data_size);
2057 ret = avcodec_decode_audio3(st->codec, samples,
2069 unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum CodecID id)
2071 while (tags->id != CODEC_ID_NONE) {
2079 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2082 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2083 if(tag == tags[i].tag)
2086 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2087 if (ff_toupper4(tag) == ff_toupper4(tags[i].tag))
2090 return CODEC_ID_NONE;
2093 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2096 for(i=0; tags && tags[i]; i++){
2097 int tag= ff_codec_get_tag(tags[i], id);
2103 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2106 for(i=0; tags && tags[i]; i++){
2107 enum CodecID id= ff_codec_get_id(tags[i], tag);
2108 if(id!=CODEC_ID_NONE) return id;
2110 return CODEC_ID_NONE;
2113 static void compute_chapters_end(AVFormatContext *s)
2117 for (i=0; i+1<s->nb_chapters; i++)
2118 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2119 assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2120 assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2121 s->chapters[i]->end = s->chapters[i+1]->start;
2124 if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2125 assert(s->start_time != AV_NOPTS_VALUE);
2126 assert(s->duration > 0);
2127 s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2129 s->chapters[i]->time_base);
2133 #define MAX_STD_TIMEBASES (60*12+5)
2134 static int get_std_framerate(int i){
2135 if(i<60*12) return i*1001;
2136 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2140 * Is the time base unreliable.
2141 * This is a heuristic to balance between quick acceptance of the values in
2142 * the headers vs. some extra checks.
2143 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2144 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2145 * And there are "variable" fps files this needs to detect as well.
2147 static int tb_unreliable(AVCodecContext *c){
2148 if( c->time_base.den >= 101L*c->time_base.num
2149 || c->time_base.den < 5L*c->time_base.num
2150 /* || c->codec_tag == AV_RL32("DIVX")
2151 || c->codec_tag == AV_RL32("XVID")*/
2152 || c->codec_id == CODEC_ID_MPEG2VIDEO
2153 || c->codec_id == CODEC_ID_H264
2159 int av_find_stream_info(AVFormatContext *ic)
2161 int i, count, ret, read_size, j;
2163 AVPacket pkt1, *pkt;
2164 int64_t last_dts[MAX_STREAMS];
2165 int64_t duration_gcd[MAX_STREAMS]={0};
2166 int duration_count[MAX_STREAMS]={0};
2167 double (*duration_error)[MAX_STD_TIMEBASES];
2168 int64_t old_offset = url_ftell(ic->pb);
2169 int64_t codec_info_duration[MAX_STREAMS]={0};
2171 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2172 if (!duration_error) return AVERROR(ENOMEM);
2174 for(i=0;i<ic->nb_streams;i++) {
2175 st = ic->streams[i];
2176 if (st->codec->codec_id == CODEC_ID_AAC) {
2177 st->codec->sample_rate = 0;
2178 st->codec->frame_size = 0;
2179 st->codec->channels = 0;
2181 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
2182 /* if(!st->time_base.num)
2184 if(!st->codec->time_base.num)
2185 st->codec->time_base= st->time_base;
2187 //only for the split stuff
2188 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2189 st->parser = av_parser_init(st->codec->codec_id);
2190 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2191 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2194 assert(!st->codec->codec);
2195 //try to just open decoders, in case this is enough to get parameters
2196 if(!has_codec_parameters(st->codec)){
2197 AVCodec *codec = avcodec_find_decoder(st->codec->codec_id);
2199 avcodec_open(st->codec, codec);
2203 for(i=0;i<MAX_STREAMS;i++){
2204 last_dts[i]= AV_NOPTS_VALUE;
2210 if(url_interrupt_cb()){
2211 ret= AVERROR(EINTR);
2212 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2216 /* check if one codec still needs to be handled */
2217 for(i=0;i<ic->nb_streams;i++) {
2218 st = ic->streams[i];
2219 if (!has_codec_parameters(st->codec))
2221 /* variable fps and no guess at the real fps */
2222 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2223 && duration_count[i]<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2225 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2227 if(st->first_dts == AV_NOPTS_VALUE)
2230 if (i == ic->nb_streams) {
2231 /* NOTE: if the format has no header, then we need to read
2232 some packets to get most of the streams, so we cannot
2234 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2235 /* if we found the info for all the codecs, we can stop */
2237 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2241 /* we did not get all the codec info, but we read too much data */
2242 if (read_size >= ic->probesize) {
2244 av_log(ic, AV_LOG_DEBUG, "Probe buffer size limit %d reached\n", ic->probesize);
2248 /* NOTE: a new stream can be added there if no header in file
2249 (AVFMTCTX_NOHEADER) */
2250 ret = av_read_frame_internal(ic, &pkt1);
2251 if(ret == AVERROR(EAGAIN))
2255 ret = -1; /* we could not have all the codec parameters before EOF */
2256 for(i=0;i<ic->nb_streams;i++) {
2257 st = ic->streams[i];
2258 if (!has_codec_parameters(st->codec)){
2260 avcodec_string(buf, sizeof(buf), st->codec, 0);
2261 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2269 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2270 if(av_dup_packet(pkt) < 0) {
2271 av_free(duration_error);
2272 return AVERROR(ENOMEM);
2275 read_size += pkt->size;
2277 st = ic->streams[pkt->stream_index];
2278 if(st->codec_info_nb_frames>1) {
2279 if (st->time_base.den > 0 && av_rescale_q(codec_info_duration[st->index], st->time_base, AV_TIME_BASE_Q) >= ic->max_analyze_duration){
2280 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2283 codec_info_duration[st->index] += pkt->duration;
2286 int index= pkt->stream_index;
2287 int64_t last= last_dts[index];
2288 int64_t duration= pkt->dts - last;
2290 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2291 double dur= duration * av_q2d(st->time_base);
2293 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2294 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2295 if(duration_count[index] < 2)
2296 memset(duration_error[index], 0, sizeof(*duration_error));
2297 for(i=1; i<MAX_STD_TIMEBASES; i++){
2298 int framerate= get_std_framerate(i);
2299 int ticks= lrintf(dur*framerate/(1001*12));
2300 double error= dur - ticks*1001*12/(double)framerate;
2301 duration_error[index][i] += error*error;
2303 duration_count[index]++;
2304 // ignore the first 4 values, they might have some random jitter
2305 if (duration_count[index] > 3)
2306 duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2308 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2309 last_dts[pkt->stream_index]= pkt->dts;
2311 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2312 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2314 st->codec->extradata_size= i;
2315 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2316 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2317 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2321 /* if still no information, we try to open the codec and to
2322 decompress the frame. We try to avoid that in most cases as
2323 it takes longer and uses more memory. For MPEG-4, we need to
2324 decompress for QuickTime. */
2325 if (!has_codec_parameters(st->codec) || !has_decode_delay_been_guessed(st))
2326 try_decode_frame(st, pkt);
2328 st->codec_info_nb_frames++;
2332 // close codecs which were opened in try_decode_frame()
2333 for(i=0;i<ic->nb_streams;i++) {
2334 st = ic->streams[i];
2335 if(st->codec->codec)
2336 avcodec_close(st->codec);
2338 for(i=0;i<ic->nb_streams;i++) {
2339 st = ic->streams[i];
2340 if(st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && codec_info_duration[i])
2341 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2342 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2343 codec_info_duration[i] *(int64_t)st->time_base.num, 60000);
2344 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2345 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2346 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2348 // the check for tb_unreliable() is not completely correct, since this is not about handling
2349 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2350 // ipmovie.c produces.
2351 if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1 && !st->r_frame_rate.num)
2352 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * duration_gcd[i], INT_MAX);
2353 if(duration_count[i] && !st->r_frame_rate.num
2354 && tb_unreliable(st->codec) /*&&
2355 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2356 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2358 double best_error= 2*av_q2d(st->time_base);
2359 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2361 for(j=1; j<MAX_STD_TIMEBASES; j++){
2362 double error= duration_error[i][j] * get_std_framerate(j);
2363 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2364 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2365 if(error < best_error){
2367 num = get_std_framerate(j);
2370 // do not increase frame rate by more than 1 % in order to match a standard rate.
2371 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2372 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2375 if (!st->r_frame_rate.num){
2376 if( st->codec->time_base.den * (int64_t)st->time_base.num
2377 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2378 st->r_frame_rate.num = st->codec->time_base.den;
2379 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2381 st->r_frame_rate.num = st->time_base.den;
2382 st->r_frame_rate.den = st->time_base.num;
2385 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2386 if(!st->codec->bits_per_coded_sample)
2387 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2391 av_estimate_timings(ic, old_offset);
2393 compute_chapters_end(ic);
2396 /* correct DTS for B-frame streams with no timestamps */
2397 for(i=0;i<ic->nb_streams;i++) {
2398 st = ic->streams[i];
2399 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2401 ppktl = &ic->packet_buffer;
2403 if(ppkt1->stream_index != i)
2405 if(ppkt1->pkt->dts < 0)
2407 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2409 ppkt1->pkt->dts -= delta;
2414 st->cur_dts -= delta;
2420 av_free(duration_error);
2425 /*******************************************************/
2427 int av_read_play(AVFormatContext *s)
2429 if (s->iformat->read_play)
2430 return s->iformat->read_play(s);
2432 return av_url_read_fpause(s->pb, 0);
2433 return AVERROR(ENOSYS);
2436 int av_read_pause(AVFormatContext *s)
2438 if (s->iformat->read_pause)
2439 return s->iformat->read_pause(s);
2441 return av_url_read_fpause(s->pb, 1);
2442 return AVERROR(ENOSYS);
2445 void av_close_input_stream(AVFormatContext *s)
2450 if (s->iformat->read_close)
2451 s->iformat->read_close(s);
2452 for(i=0;i<s->nb_streams;i++) {
2453 /* free all data in a stream component */
2456 av_parser_close(st->parser);
2457 av_free_packet(&st->cur_pkt);
2459 av_metadata_free(&st->metadata);
2460 av_free(st->index_entries);
2461 av_free(st->codec->extradata);
2463 #if FF_API_OLD_METADATA
2464 av_free(st->filename);
2466 av_free(st->priv_data);
2469 for(i=s->nb_programs-1; i>=0; i--) {
2470 #if FF_API_OLD_METADATA
2471 av_freep(&s->programs[i]->provider_name);
2472 av_freep(&s->programs[i]->name);
2474 av_metadata_free(&s->programs[i]->metadata);
2475 av_freep(&s->programs[i]->stream_index);
2476 av_freep(&s->programs[i]);
2478 av_freep(&s->programs);
2479 flush_packet_queue(s);
2480 av_freep(&s->priv_data);
2481 while(s->nb_chapters--) {
2482 #if FF_API_OLD_METADATA
2483 av_free(s->chapters[s->nb_chapters]->title);
2485 av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2486 av_free(s->chapters[s->nb_chapters]);
2488 av_freep(&s->chapters);
2489 av_metadata_free(&s->metadata);
2493 void av_close_input_file(AVFormatContext *s)
2495 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2496 av_close_input_stream(s);
2501 AVStream *av_new_stream(AVFormatContext *s, int id)
2506 if (s->nb_streams >= MAX_STREAMS){
2507 av_log(s, AV_LOG_ERROR, "Too many streams\n");
2511 st = av_mallocz(sizeof(AVStream));
2515 st->codec= avcodec_alloc_context();
2517 /* no default bitrate if decoding */
2518 st->codec->bit_rate = 0;
2520 st->index = s->nb_streams;
2522 st->start_time = AV_NOPTS_VALUE;
2523 st->duration = AV_NOPTS_VALUE;
2524 /* we set the current DTS to 0 so that formats without any timestamps
2525 but durations get some timestamps, formats with some unknown
2526 timestamps have their first few packets buffered and the
2527 timestamps corrected before they are returned to the user */
2529 st->first_dts = AV_NOPTS_VALUE;
2530 st->probe_packets = MAX_PROBE_PACKETS;
2532 /* default pts setting is MPEG-like */
2533 av_set_pts_info(st, 33, 1, 90000);
2534 st->last_IP_pts = AV_NOPTS_VALUE;
2535 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2536 st->pts_buffer[i]= AV_NOPTS_VALUE;
2537 st->reference_dts = AV_NOPTS_VALUE;
2539 st->sample_aspect_ratio = (AVRational){0,1};
2541 s->streams[s->nb_streams++] = st;
2545 AVProgram *av_new_program(AVFormatContext *ac, int id)
2547 AVProgram *program=NULL;
2551 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2554 for(i=0; i<ac->nb_programs; i++)
2555 if(ac->programs[i]->id == id)
2556 program = ac->programs[i];
2559 program = av_mallocz(sizeof(AVProgram));
2562 dynarray_add(&ac->programs, &ac->nb_programs, program);
2563 program->discard = AVDISCARD_NONE;
2570 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2572 AVChapter *chapter = NULL;
2575 for(i=0; i<s->nb_chapters; i++)
2576 if(s->chapters[i]->id == id)
2577 chapter = s->chapters[i];
2580 chapter= av_mallocz(sizeof(AVChapter));
2583 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2585 #if FF_API_OLD_METADATA
2586 av_free(chapter->title);
2588 av_metadata_set2(&chapter->metadata, "title", title, 0);
2590 chapter->time_base= time_base;
2591 chapter->start = start;
2597 /************************************************************/
2598 /* output media file */
2600 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2604 if (s->oformat->priv_data_size > 0) {
2605 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2607 return AVERROR(ENOMEM);
2609 s->priv_data = NULL;
2611 if (s->oformat->set_parameters) {
2612 ret = s->oformat->set_parameters(s, ap);
2619 static int validate_codec_tag(AVFormatContext *s, AVStream *st)
2621 const AVCodecTag *avctag;
2623 enum CodecID id = CODEC_ID_NONE;
2624 unsigned int tag = 0;
2627 * Check that tag + id is in the table
2628 * If neither is in the table -> OK
2629 * If tag is in the table with another id -> FAIL
2630 * If id is in the table with another tag -> FAIL unless strict < normal
2632 for (n = 0; s->oformat->codec_tag[n]; n++) {
2633 avctag = s->oformat->codec_tag[n];
2634 while (avctag->id != CODEC_ID_NONE) {
2635 if (ff_toupper4(avctag->tag) == ff_toupper4(st->codec->codec_tag)) {
2637 if (id == st->codec->codec_id)
2640 if (avctag->id == st->codec->codec_id)
2645 if (id != CODEC_ID_NONE)
2647 if (tag && (st->codec->strict_std_compliance >= FF_COMPLIANCE_NORMAL))
2652 int av_write_header(AVFormatContext *s)
2657 // some sanity checks
2658 if (s->nb_streams == 0) {
2659 av_log(s, AV_LOG_ERROR, "no streams\n");
2660 return AVERROR(EINVAL);
2663 for(i=0;i<s->nb_streams;i++) {
2666 switch (st->codec->codec_type) {
2667 case AVMEDIA_TYPE_AUDIO:
2668 if(st->codec->sample_rate<=0){
2669 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2670 return AVERROR(EINVAL);
2672 if(!st->codec->block_align)
2673 st->codec->block_align = st->codec->channels *
2674 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2676 case AVMEDIA_TYPE_VIDEO:
2677 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2678 av_log(s, AV_LOG_ERROR, "time base not set\n");
2679 return AVERROR(EINVAL);
2681 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2682 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2683 return AVERROR(EINVAL);
2685 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2686 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2687 return AVERROR(EINVAL);
2692 if(s->oformat->codec_tag){
2693 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)){
2694 //the current rawvideo encoding system ends up setting the wrong codec_tag for avi, we override it here
2695 st->codec->codec_tag= 0;
2697 if(st->codec->codec_tag){
2698 if (!validate_codec_tag(s, st)) {
2700 av_get_codec_tag_string(tagbuf, sizeof(tagbuf), st->codec->codec_tag);
2701 av_log(s, AV_LOG_ERROR,
2702 "Tag %s/0x%08x incompatible with output codec id '%d'\n",
2703 tagbuf, st->codec->codec_tag, st->codec->codec_id);
2704 return AVERROR_INVALIDDATA;
2707 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2710 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2711 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2712 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2715 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2716 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2718 return AVERROR(ENOMEM);
2721 #if FF_API_OLD_METADATA
2722 ff_metadata_mux_compat(s);
2725 /* set muxer identification string */
2726 if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2730 if (!(m = av_mallocz(sizeof(AVMetadata))))
2731 return AVERROR(ENOMEM);
2732 av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2733 metadata_conv(&m, s->oformat->metadata_conv, NULL);
2734 if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2735 av_metadata_set2(&s->metadata, t->key, t->value, 0);
2736 av_metadata_free(&m);
2739 if(s->oformat->write_header){
2740 ret = s->oformat->write_header(s);
2745 /* init PTS generation */
2746 for(i=0;i<s->nb_streams;i++) {
2747 int64_t den = AV_NOPTS_VALUE;
2750 switch (st->codec->codec_type) {
2751 case AVMEDIA_TYPE_AUDIO:
2752 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2754 case AVMEDIA_TYPE_VIDEO:
2755 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2760 if (den != AV_NOPTS_VALUE) {
2762 return AVERROR_INVALIDDATA;
2763 av_frac_init(&st->pts, 0, 0, den);
2769 //FIXME merge with compute_pkt_fields
2770 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2771 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2772 int num, den, frame_size, i;
2774 // 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);
2776 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2779 /* duration field */
2780 if (pkt->duration == 0) {
2781 compute_frame_duration(&num, &den, st, NULL, pkt);
2783 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2787 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2790 //XXX/FIXME this is a temporary hack until all encoders output pts
2791 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2793 // pkt->pts= st->cur_dts;
2794 pkt->pts= st->pts.val;
2797 //calculate dts from pts
2798 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2799 st->pts_buffer[0]= pkt->pts;
2800 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2801 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2802 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2803 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2805 pkt->dts= st->pts_buffer[0];
2808 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2809 av_log(s, AV_LOG_ERROR,
2810 "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2811 st->index, st->cur_dts, pkt->dts);
2814 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2815 av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2819 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2820 st->cur_dts= pkt->dts;
2821 st->pts.val= pkt->dts;
2824 switch (st->codec->codec_type) {
2825 case AVMEDIA_TYPE_AUDIO:
2826 frame_size = get_audio_frame_size(st->codec, pkt->size);
2828 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2829 likely equal to the encoder delay, but it would be better if we
2830 had the real timestamps from the encoder */
2831 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2832 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2835 case AVMEDIA_TYPE_VIDEO:
2836 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2844 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2846 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2848 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2851 ret= s->oformat->write_packet(s, pkt);
2853 ret= url_ferror(s->pb);
2857 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2858 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2860 AVPacketList **next_point, *this_pktl;
2862 this_pktl = av_mallocz(sizeof(AVPacketList));
2863 this_pktl->pkt= *pkt;
2864 pkt->destruct= NULL; // do not free original but only the copy
2865 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
2867 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2868 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2870 next_point = &s->packet_buffer;
2873 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2874 while(!compare(s, &(*next_point)->pkt, pkt)){
2875 next_point= &(*next_point)->next;
2879 next_point = &(s->packet_buffer_end->next);
2882 assert(!*next_point);
2884 s->packet_buffer_end= this_pktl;
2887 this_pktl->next= *next_point;
2889 s->streams[pkt->stream_index]->last_in_packet_buffer=
2890 *next_point= this_pktl;
2893 int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2895 AVStream *st = s->streams[ pkt ->stream_index];
2896 AVStream *st2= s->streams[ next->stream_index];
2897 int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2898 int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2899 return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2902 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2908 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2911 for(i=0; i < s->nb_streams; i++)
2912 stream_count+= !!s->streams[i]->last_in_packet_buffer;
2914 if(stream_count && (s->nb_streams == stream_count || flush)){
2915 pktl= s->packet_buffer;
2918 s->packet_buffer= pktl->next;
2919 if(!s->packet_buffer)
2920 s->packet_buffer_end= NULL;
2922 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2923 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2927 av_init_packet(out);
2933 * Interleave an AVPacket correctly so it can be muxed.
2934 * @param out the interleaved packet will be output here
2935 * @param in the input packet
2936 * @param flush 1 if no further packets are available as input and all
2937 * remaining packets should be output
2938 * @return 1 if a packet was output, 0 if no packet could be output,
2939 * < 0 if an error occurred
2941 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2942 if(s->oformat->interleave_packet)
2943 return s->oformat->interleave_packet(s, out, in, flush);
2945 return av_interleave_packet_per_dts(s, out, in, flush);
2948 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2949 AVStream *st= s->streams[ pkt->stream_index];
2951 //FIXME/XXX/HACK drop zero sized packets
2952 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2955 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2956 if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2959 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2964 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2965 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2968 ret= s->oformat->write_packet(s, &opkt);
2970 av_free_packet(&opkt);
2975 if(url_ferror(s->pb))
2976 return url_ferror(s->pb);
2980 int av_write_trailer(AVFormatContext *s)
2986 ret= av_interleave_packet(s, &pkt, NULL, 1);
2987 if(ret<0) //FIXME cleanup needed for ret<0 ?
2992 ret= s->oformat->write_packet(s, &pkt);
2994 av_free_packet(&pkt);
2998 if(url_ferror(s->pb))
3002 if(s->oformat->write_trailer)
3003 ret = s->oformat->write_trailer(s);
3006 ret=url_ferror(s->pb);
3007 for(i=0;i<s->nb_streams;i++) {
3008 av_freep(&s->streams[i]->priv_data);
3009 av_freep(&s->streams[i]->index_entries);
3011 av_freep(&s->priv_data);
3015 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
3018 AVProgram *program=NULL;
3021 if (idx >= ac->nb_streams) {
3022 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
3026 for(i=0; i<ac->nb_programs; i++){
3027 if(ac->programs[i]->id != progid)
3029 program = ac->programs[i];
3030 for(j=0; j<program->nb_stream_indexes; j++)
3031 if(program->stream_index[j] == idx)
3034 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
3037 program->stream_index = tmp;
3038 program->stream_index[program->nb_stream_indexes++] = idx;
3043 static void print_fps(double d, const char *postfix){
3044 uint64_t v= lrintf(d*100);
3045 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
3046 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
3047 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
3050 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
3052 if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
3053 AVMetadataTag *tag=NULL;
3055 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
3056 while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
3057 if(strcmp("language", tag->key))
3058 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
3063 /* "user interface" functions */
3064 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
3067 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
3068 AVStream *st = ic->streams[i];
3069 int g = av_gcd(st->time_base.num, st->time_base.den);
3070 AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
3071 avcodec_string(buf, sizeof(buf), st->codec, is_output);
3072 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
3073 /* the pid is an important information, so we display it */
3074 /* XXX: add a generic system */
3075 if (flags & AVFMT_SHOW_IDS)
3076 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
3078 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
3079 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
3080 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3081 if (st->sample_aspect_ratio.num && // default
3082 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3083 AVRational display_aspect_ratio;
3084 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3085 st->codec->width*st->sample_aspect_ratio.num,
3086 st->codec->height*st->sample_aspect_ratio.den,
3088 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3089 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3090 display_aspect_ratio.num, display_aspect_ratio.den);
3092 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3093 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3094 print_fps(av_q2d(st->avg_frame_rate), "fps");
3095 if(st->r_frame_rate.den && st->r_frame_rate.num)
3096 print_fps(av_q2d(st->r_frame_rate), "tbr");
3097 if(st->time_base.den && st->time_base.num)
3098 print_fps(1/av_q2d(st->time_base), "tbn");
3099 if(st->codec->time_base.den && st->codec->time_base.num)
3100 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3102 av_log(NULL, AV_LOG_INFO, "\n");
3103 dump_metadata(NULL, st->metadata, " ");
3106 void dump_format(AVFormatContext *ic,
3112 uint8_t *printed = av_mallocz(ic->nb_streams);
3113 if (ic->nb_streams && !printed)
3116 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3117 is_output ? "Output" : "Input",
3119 is_output ? ic->oformat->name : ic->iformat->name,
3120 is_output ? "to" : "from", url);
3121 dump_metadata(NULL, ic->metadata, " ");
3123 av_log(NULL, AV_LOG_INFO, " Duration: ");
3124 if (ic->duration != AV_NOPTS_VALUE) {
3125 int hours, mins, secs, us;
3126 secs = ic->duration / AV_TIME_BASE;
3127 us = ic->duration % AV_TIME_BASE;
3132 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3133 (100 * us) / AV_TIME_BASE);
3135 av_log(NULL, AV_LOG_INFO, "N/A");
3137 if (ic->start_time != AV_NOPTS_VALUE) {
3139 av_log(NULL, AV_LOG_INFO, ", start: ");
3140 secs = ic->start_time / AV_TIME_BASE;
3141 us = ic->start_time % AV_TIME_BASE;
3142 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3143 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3145 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3147 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3149 av_log(NULL, AV_LOG_INFO, "N/A");
3151 av_log(NULL, AV_LOG_INFO, "\n");
3153 for (i = 0; i < ic->nb_chapters; i++) {
3154 AVChapter *ch = ic->chapters[i];
3155 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3156 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3157 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3159 dump_metadata(NULL, ch->metadata, " ");
3161 if(ic->nb_programs) {
3162 int j, k, total = 0;
3163 for(j=0; j<ic->nb_programs; j++) {
3164 AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3166 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3167 name ? name->value : "");
3168 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3169 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3170 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3171 printed[ic->programs[j]->stream_index[k]] = 1;
3173 total += ic->programs[j]->nb_stream_indexes;
3175 if (total < ic->nb_streams)
3176 av_log(NULL, AV_LOG_INFO, " No Program\n");
3178 for(i=0;i<ic->nb_streams;i++)
3180 dump_stream_format(ic, i, index, is_output);
3185 #if LIBAVFORMAT_VERSION_MAJOR < 53
3186 #include "libavcore/parseutils.h"
3188 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3190 return av_parse_video_size(width_ptr, height_ptr, str);
3193 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3195 AVRational frame_rate;
3196 int ret = av_parse_video_rate(&frame_rate, arg);
3197 *frame_rate_num= frame_rate.num;
3198 *frame_rate_den= frame_rate.den;
3203 int64_t av_gettime(void)
3206 gettimeofday(&tv,NULL);
3207 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3210 uint64_t ff_ntp_time(void)
3212 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3215 int64_t parse_date(const char *datestr, int duration)
3221 static const char * const date_fmt[] = {
3225 static const char * const time_fmt[] = {
3235 time_t now = time(0);
3237 len = strlen(datestr);
3239 lastch = datestr[len - 1];
3242 is_utc = (lastch == 'z' || lastch == 'Z');
3244 memset(&dt, 0, sizeof(dt));
3249 if (!strncasecmp(datestr, "now", len))
3250 return (int64_t) now * 1000000;
3252 /* parse the year-month-day part */
3253 for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3254 q = small_strptime(p, date_fmt[i], &dt);
3260 /* if the year-month-day part is missing, then take the
3261 * current year-month-day time */
3266 dt = *localtime(&now);
3268 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3273 if (*p == 'T' || *p == 't' || *p == ' ')
3276 /* parse the hour-minute-second part */
3277 for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3278 q = small_strptime(p, time_fmt[i], &dt);
3284 /* parse datestr as a duration */
3289 /* parse datestr as HH:MM:SS */
3290 q = small_strptime(p, time_fmt[0], &dt);
3292 /* parse datestr as S+ */
3293 dt.tm_sec = strtol(p, (char **)&q, 10);
3295 /* the parsing didn't succeed */
3302 /* Now we have all the fields that we can get */
3308 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3310 dt.tm_isdst = -1; /* unknown */
3320 /* parse the .m... part */
3324 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3327 val += n * (*q - '0');
3331 return negative ? -t : t;
3334 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3344 while (*p != '\0' && *p != '=' && *p != '&') {
3345 if ((q - tag) < sizeof(tag) - 1)
3353 while (*p != '&' && *p != '\0') {
3354 if ((q - arg) < arg_size - 1) {
3364 if (!strcmp(tag, tag1))
3373 int av_get_frame_filename(char *buf, int buf_size,
3374 const char *path, int number)
3377 char *q, buf1[20], c;
3378 int nd, len, percentd_found;
3390 while (isdigit(*p)) {
3391 nd = nd * 10 + *p++ - '0';
3394 } while (isdigit(c));
3403 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3405 if ((q - buf + len) > buf_size - 1)
3407 memcpy(q, buf1, len);
3415 if ((q - buf) < buf_size - 1)
3419 if (!percentd_found)
3428 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3432 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3434 for(i=0;i<size;i+=16) {
3441 PRINT(" %02x", buf[i+j]);
3446 for(j=0;j<len;j++) {
3448 if (c < ' ' || c > '~')
3457 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3459 hex_dump_internal(NULL, f, 0, buf, size);
3462 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3464 hex_dump_internal(avcl, NULL, level, buf, size);
3467 //FIXME needs to know the time_base
3468 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3471 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3472 PRINT("stream #%d:\n", pkt->stream_index);
3473 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3474 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3475 /* DTS is _always_ valid after av_read_frame() */
3477 if (pkt->dts == AV_NOPTS_VALUE)
3480 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3481 /* PTS may not be known if B-frames are present. */
3483 if (pkt->pts == AV_NOPTS_VALUE)
3486 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3488 PRINT(" size=%d\n", pkt->size);
3491 av_hex_dump(f, pkt->data, pkt->size);
3494 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3496 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3499 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3501 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3504 #if LIBAVFORMAT_VERSION_MAJOR < 53
3505 attribute_deprecated
3506 void ff_url_split(char *proto, int proto_size,
3507 char *authorization, int authorization_size,
3508 char *hostname, int hostname_size,
3510 char *path, int path_size,
3513 av_url_split(proto, proto_size,
3514 authorization, authorization_size,
3515 hostname, hostname_size,
3522 void av_url_split(char *proto, int proto_size,
3523 char *authorization, int authorization_size,
3524 char *hostname, int hostname_size,
3526 char *path, int path_size,
3529 const char *p, *ls, *at, *col, *brk;
3531 if (port_ptr) *port_ptr = -1;
3532 if (proto_size > 0) proto[0] = 0;
3533 if (authorization_size > 0) authorization[0] = 0;
3534 if (hostname_size > 0) hostname[0] = 0;
3535 if (path_size > 0) path[0] = 0;
3537 /* parse protocol */
3538 if ((p = strchr(url, ':'))) {
3539 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3544 /* no protocol means plain filename */
3545 av_strlcpy(path, url, path_size);
3549 /* separate path from hostname */
3550 ls = strchr(p, '/');
3552 ls = strchr(p, '?');
3554 av_strlcpy(path, ls, path_size);
3556 ls = &p[strlen(p)]; // XXX
3558 /* the rest is hostname, use that to parse auth/port */
3560 /* authorization (user[:pass]@hostname) */
3561 if ((at = strchr(p, '@')) && at < ls) {
3562 av_strlcpy(authorization, p,
3563 FFMIN(authorization_size, at + 1 - p));
3564 p = at + 1; /* skip '@' */
3567 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3569 av_strlcpy(hostname, p + 1,
3570 FFMIN(hostname_size, brk - p));
3571 if (brk[1] == ':' && port_ptr)
3572 *port_ptr = atoi(brk + 2);
3573 } else if ((col = strchr(p, ':')) && col < ls) {
3574 av_strlcpy(hostname, p,
3575 FFMIN(col + 1 - p, hostname_size));
3576 if (port_ptr) *port_ptr = atoi(col + 1);
3578 av_strlcpy(hostname, p,
3579 FFMIN(ls + 1 - p, hostname_size));
3583 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3586 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3589 'C', 'D', 'E', 'F' };
3590 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3593 'c', 'd', 'e', 'f' };
3594 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3596 for(i = 0; i < s; i++) {
3597 buff[i * 2] = hex_table[src[i] >> 4];
3598 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3604 int ff_hex_to_data(uint8_t *data, const char *p)
3611 p += strspn(p, SPACE_CHARS);
3614 c = toupper((unsigned char) *p++);
3615 if (c >= '0' && c <= '9')
3617 else if (c >= 'A' && c <= 'F')
3632 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3633 unsigned int pts_num, unsigned int pts_den)
3635 s->pts_wrap_bits = pts_wrap_bits;
3637 if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3638 if(s->time_base.num != pts_num)
3639 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3641 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3643 if(!s->time_base.num || !s->time_base.den)
3644 s->time_base.num= s->time_base.den= 0;
3647 int ff_url_join(char *str, int size, const char *proto,
3648 const char *authorization, const char *hostname,
3649 int port, const char *fmt, ...)
3652 struct addrinfo hints, *ai;
3657 av_strlcatf(str, size, "%s://", proto);
3658 if (authorization && authorization[0])
3659 av_strlcatf(str, size, "%s@", authorization);
3660 #if CONFIG_NETWORK && defined(AF_INET6)
3661 /* Determine if hostname is a numerical IPv6 address,
3662 * properly escape it within [] in that case. */
3663 memset(&hints, 0, sizeof(hints));
3664 hints.ai_flags = AI_NUMERICHOST;
3665 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3666 if (ai->ai_family == AF_INET6) {
3667 av_strlcat(str, "[", size);
3668 av_strlcat(str, hostname, size);
3669 av_strlcat(str, "]", size);
3671 av_strlcat(str, hostname, size);
3676 /* Not an IPv6 address, just output the plain string. */
3677 av_strlcat(str, hostname, size);
3680 av_strlcatf(str, size, ":%d", port);
3683 int len = strlen(str);
3686 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
3692 int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
3693 AVFormatContext *src)
3698 local_pkt.stream_index = dst_stream;
3699 if (pkt->pts != AV_NOPTS_VALUE)
3700 local_pkt.pts = av_rescale_q(pkt->pts,
3701 src->streams[pkt->stream_index]->time_base,
3702 dst->streams[dst_stream]->time_base);
3703 if (pkt->dts != AV_NOPTS_VALUE)
3704 local_pkt.dts = av_rescale_q(pkt->dts,
3705 src->streams[pkt->stream_index]->time_base,
3706 dst->streams[dst_stream]->time_base);
3707 return av_write_frame(dst, &local_pkt);
3710 void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
3713 const char *ptr = str;
3715 /* Parse key=value pairs. */
3718 char *dest = NULL, *dest_end;
3719 int key_len, dest_len = 0;
3721 /* Skip whitespace and potential commas. */
3722 while (*ptr && (isspace(*ptr) || *ptr == ','))
3729 if (!(ptr = strchr(key, '=')))
3732 key_len = ptr - key;
3734 callback_get_buf(context, key, key_len, &dest, &dest_len);
3735 dest_end = dest + dest_len - 1;
3739 while (*ptr && *ptr != '\"') {
3743 if (dest && dest < dest_end)
3747 if (dest && dest < dest_end)
3755 for (; *ptr && !(isspace(*ptr) || *ptr == ','); ptr++)
3756 if (dest && dest < dest_end)