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/opt.h"
25 #include "libavutil/avstring.h"
27 #include "audiointerleave.h"
40 * @file libavformat/utils.c
41 * various utility functions for use within FFmpeg
44 unsigned avformat_version(void)
46 return LIBAVFORMAT_VERSION_INT;
49 const char *avformat_configuration(void)
51 return FFMPEG_CONFIGURATION;
54 const char *avformat_license(void)
56 #define LICENSE_PREFIX "libavformat license: "
57 return LICENSE_PREFIX FFMPEG_LICENSE + sizeof(LICENSE_PREFIX) - 1;
60 /* fraction handling */
63 * f = val + (num / den) + 0.5.
65 * 'num' is normalized so that it is such as 0 <= num < den.
67 * @param f fractional number
68 * @param val integer value
69 * @param num must be >= 0
70 * @param den must be >= 1
72 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
85 * Fractional addition to f: f = f + (incr / f->den).
87 * @param f fractional number
88 * @param incr increment, can be positive or negative
90 static void av_frac_add(AVFrac *f, int64_t incr)
103 } else if (num >= den) {
110 /** head of registered input format linked list */
111 AVInputFormat *first_iformat = NULL;
112 /** head of registered output format linked list */
113 AVOutputFormat *first_oformat = NULL;
115 AVInputFormat *av_iformat_next(AVInputFormat *f)
117 if(f) return f->next;
118 else return first_iformat;
121 AVOutputFormat *av_oformat_next(AVOutputFormat *f)
123 if(f) return f->next;
124 else return first_oformat;
127 void av_register_input_format(AVInputFormat *format)
131 while (*p != NULL) p = &(*p)->next;
136 void av_register_output_format(AVOutputFormat *format)
140 while (*p != NULL) p = &(*p)->next;
145 int av_match_ext(const char *filename, const char *extensions)
153 ext = strrchr(filename, '.');
159 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
162 if (!strcasecmp(ext1, ext))
172 static int match_format(const char *name, const char *names)
180 namelen = strlen(name);
181 while ((p = strchr(names, ','))) {
182 len = FFMAX(p - names, namelen);
183 if (!strncasecmp(name, names, len))
187 return !strcasecmp(name, names);
190 #if LIBAVFORMAT_VERSION_MAJOR < 53
191 AVOutputFormat *guess_format(const char *short_name, const char *filename,
192 const char *mime_type)
194 return av_guess_format(short_name, filename, mime_type);
198 AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
199 const char *mime_type)
201 AVOutputFormat *fmt, *fmt_found;
202 int score_max, score;
204 /* specific test for image sequences */
205 #if CONFIG_IMAGE2_MUXER
206 if (!short_name && filename &&
207 av_filename_number_test(filename) &&
208 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
209 return av_guess_format("image2", NULL, NULL);
212 /* Find the proper file type. */
216 while (fmt != NULL) {
218 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
220 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
222 if (filename && fmt->extensions &&
223 av_match_ext(filename, fmt->extensions)) {
226 if (score > score_max) {
235 #if LIBAVFORMAT_VERSION_MAJOR < 53
236 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
237 const char *mime_type)
239 AVOutputFormat *fmt = av_guess_format(short_name, filename, mime_type);
242 AVOutputFormat *stream_fmt;
243 char stream_format_name[64];
245 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
246 stream_fmt = av_guess_format(stream_format_name, NULL, NULL);
256 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
257 const char *filename, const char *mime_type, enum AVMediaType type){
258 if(type == AVMEDIA_TYPE_VIDEO){
259 enum CodecID codec_id= CODEC_ID_NONE;
261 #if CONFIG_IMAGE2_MUXER
262 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
263 codec_id= av_guess_image2_codec(filename);
266 if(codec_id == CODEC_ID_NONE)
267 codec_id= fmt->video_codec;
269 }else if(type == AVMEDIA_TYPE_AUDIO)
270 return fmt->audio_codec;
272 return CODEC_ID_NONE;
275 AVInputFormat *av_find_input_format(const char *short_name)
278 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
279 if (match_format(short_name, fmt->name))
285 /* memory handling */
288 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
290 int ret= av_new_packet(pkt, size);
295 pkt->pos= url_ftell(s);
297 ret= get_buffer(s, pkt->data, size);
301 av_shrink_packet(pkt, ret);
307 int av_filename_number_test(const char *filename)
310 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
313 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
315 AVInputFormat *fmt1, *fmt;
319 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
320 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
323 if (fmt1->read_probe) {
324 score = fmt1->read_probe(pd);
325 } else if (fmt1->extensions) {
326 if (av_match_ext(pd->filename, fmt1->extensions)) {
330 if (score > *score_max) {
333 }else if (score == *score_max)
339 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
341 return av_probe_input_format2(pd, is_opened, &score);
344 static int set_codec_from_probe_data(AVFormatContext *s, AVStream *st, AVProbeData *pd, int score)
347 fmt = av_probe_input_format2(pd, 1, &score);
350 av_log(s, AV_LOG_DEBUG, "Probe with size=%d, packets=%d detected %s with score=%d\n",
351 pd->buf_size, MAX_PROBE_PACKETS - st->probe_packets, fmt->name, score);
352 if (!strcmp(fmt->name, "mp3")) {
353 st->codec->codec_id = CODEC_ID_MP3;
354 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
355 } else if (!strcmp(fmt->name, "ac3")) {
356 st->codec->codec_id = CODEC_ID_AC3;
357 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
358 } else if (!strcmp(fmt->name, "eac3")) {
359 st->codec->codec_id = CODEC_ID_EAC3;
360 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
361 } else if (!strcmp(fmt->name, "mpegvideo")) {
362 st->codec->codec_id = CODEC_ID_MPEG2VIDEO;
363 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
364 } else if (!strcmp(fmt->name, "m4v")) {
365 st->codec->codec_id = CODEC_ID_MPEG4;
366 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
367 } else if (!strcmp(fmt->name, "h264")) {
368 st->codec->codec_id = CODEC_ID_H264;
369 st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
370 } else if (!strcmp(fmt->name, "dts")) {
371 st->codec->codec_id = CODEC_ID_DTS;
372 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
373 } else if (!strcmp(fmt->name, "aac")) {
374 st->codec->codec_id = CODEC_ID_AAC;
375 st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
381 /************************************************************/
382 /* input media file */
385 * Open a media file from an IO stream. 'fmt' must be specified.
387 int av_open_input_stream(AVFormatContext **ic_ptr,
388 ByteIOContext *pb, const char *filename,
389 AVInputFormat *fmt, AVFormatParameters *ap)
393 AVFormatParameters default_ap;
397 memset(ap, 0, sizeof(default_ap));
400 if(!ap->prealloced_context)
401 ic = avformat_alloc_context();
405 err = AVERROR(ENOMEM);
410 ic->duration = AV_NOPTS_VALUE;
411 ic->start_time = AV_NOPTS_VALUE;
412 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
414 /* allocate private data */
415 if (fmt->priv_data_size > 0) {
416 ic->priv_data = av_mallocz(fmt->priv_data_size);
417 if (!ic->priv_data) {
418 err = AVERROR(ENOMEM);
422 ic->priv_data = NULL;
425 if (ic->iformat->read_header) {
426 err = ic->iformat->read_header(ic, ap);
431 if (pb && !ic->data_offset)
432 ic->data_offset = url_ftell(ic->pb);
434 #if LIBAVFORMAT_VERSION_MAJOR < 53
435 ff_metadata_demux_compat(ic);
438 ic->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
445 av_freep(&ic->priv_data);
446 for(i=0;i<ic->nb_streams;i++) {
447 AVStream *st = ic->streams[i];
449 av_free(st->priv_data);
450 av_free(st->codec->extradata);
460 /** size of probe buffer, for guessing file type from file contents */
461 #define PROBE_BUF_MIN 2048
462 #define PROBE_BUF_MAX (1<<20)
464 int ff_probe_input_buffer(ByteIOContext **pb, AVInputFormat **fmt,
465 const char *filename, void *logctx,
466 unsigned int offset, unsigned int max_probe_size)
468 AVProbeData pd = { filename ? filename : "", NULL, -offset };
469 unsigned char *buf = NULL;
470 int ret = 0, probe_size;
472 if (!max_probe_size) {
473 max_probe_size = PROBE_BUF_MAX;
474 } else if (max_probe_size > PROBE_BUF_MAX) {
475 max_probe_size = PROBE_BUF_MAX;
476 } else if (max_probe_size < PROBE_BUF_MIN) {
477 return AVERROR(EINVAL);
480 if (offset >= max_probe_size) {
481 return AVERROR(EINVAL);
484 for(probe_size= PROBE_BUF_MIN; probe_size<=max_probe_size && !*fmt && ret >= 0;
485 probe_size = FFMIN(probe_size<<1, FFMAX(max_probe_size, probe_size+1))) {
486 int ret, score = probe_size < max_probe_size ? AVPROBE_SCORE_MAX/4 : 0;
487 int buf_offset = (probe_size == PROBE_BUF_MIN) ? 0 : probe_size>>1;
489 if (probe_size < offset) {
493 /* read probe data */
494 buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
495 if ((ret = get_buffer(*pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
496 /* fail if error was not end of file, otherwise, lower score */
497 if (ret != AVERROR_EOF) {
502 ret = 0; /* error was end of file, nothing read */
505 pd.buf = &buf[offset];
507 memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);
509 /* guess file format */
510 *fmt = av_probe_input_format2(&pd, 1, &score);
512 if(score <= AVPROBE_SCORE_MAX/4){ //this can only be true in the last iteration
513 av_log(logctx, AV_LOG_WARNING, "Format detected only with low score of %d, misdetection possible!\n", score);
515 av_log(logctx, AV_LOG_DEBUG, "Probed with size=%d and score=%d\n", probe_size, score);
522 return AVERROR_INVALIDDATA;
525 if (url_fseek(*pb, 0, SEEK_SET) < 0) {
527 if (url_fopen(pb, filename, URL_RDONLY) < 0)
534 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
537 AVFormatParameters *ap)
540 AVProbeData probe_data, *pd = &probe_data;
541 ByteIOContext *pb = NULL;
542 void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
546 pd->filename = filename;
551 /* guess format if no file can be opened */
552 fmt = av_probe_input_format(pd, 0);
555 /* Do not open file if the format does not need it. XXX: specific
556 hack needed to handle RTSP/TCP */
557 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
558 /* if no file needed do not try to open one */
559 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
563 url_setbufsize(pb, buf_size);
565 if ((err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, 0)) < 0) {
570 /* if still no format found, error */
572 err = AVERROR_INVALIDDATA;
576 /* check filename in case an image number is expected */
577 if (fmt->flags & AVFMT_NEEDNUMBER) {
578 if (!av_filename_number_test(filename)) {
579 err = AVERROR_NUMEXPECTED;
583 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
591 if (ap && ap->prealloced_context)
598 /*******************************************************/
600 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
601 AVPacketList **plast_pktl){
602 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
607 (*plast_pktl)->next = pktl;
609 *packet_buffer = pktl;
611 /* add the packet in the buffered packet list */
617 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
623 AVPacketList *pktl = s->raw_packet_buffer;
627 if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
628 !s->streams[pkt->stream_index]->probe_packets ||
629 s->raw_packet_buffer_remaining_size < pkt->size){
630 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
633 s->raw_packet_buffer = pktl->next;
634 s->raw_packet_buffer_remaining_size += pkt->size;
641 ret= s->iformat->read_packet(s, pkt);
643 if (!pktl || ret == AVERROR(EAGAIN))
645 for (i = 0; i < s->nb_streams; i++)
646 s->streams[i]->probe_packets = 0;
649 st= s->streams[pkt->stream_index];
651 switch(st->codec->codec_type){
652 case AVMEDIA_TYPE_VIDEO:
653 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
655 case AVMEDIA_TYPE_AUDIO:
656 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
658 case AVMEDIA_TYPE_SUBTITLE:
659 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
663 if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
667 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
668 s->raw_packet_buffer_remaining_size -= pkt->size;
670 if(st->codec->codec_id == CODEC_ID_PROBE){
671 AVProbeData *pd = &st->probe_data;
672 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
675 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
676 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
677 pd->buf_size += pkt->size;
678 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
680 if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
681 set_codec_from_probe_data(s, st, pd, 1);
682 if(st->codec->codec_id != CODEC_ID_PROBE){
685 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
692 /**********************************************************/
695 * Get the number of samples of an audio frame. Return -1 on error.
697 static int get_audio_frame_size(AVCodecContext *enc, int size)
701 if(enc->codec_id == CODEC_ID_VORBIS)
704 if (enc->frame_size <= 1) {
705 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
707 if (bits_per_sample) {
708 if (enc->channels == 0)
710 frame_size = (size << 3) / (bits_per_sample * enc->channels);
712 /* used for example by ADPCM codecs */
713 if (enc->bit_rate == 0)
715 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
718 frame_size = enc->frame_size;
725 * Return the frame duration in seconds. Return 0 if not available.
727 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
728 AVCodecParserContext *pc, AVPacket *pkt)
734 switch(st->codec->codec_type) {
735 case AVMEDIA_TYPE_VIDEO:
736 if(st->time_base.num*1000LL > st->time_base.den){
737 *pnum = st->time_base.num;
738 *pden = st->time_base.den;
739 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
740 *pnum = st->codec->time_base.num;
741 *pden = st->codec->time_base.den;
742 if (pc && pc->repeat_pict) {
743 *pnum = (*pnum) * (1 + pc->repeat_pict);
747 case AVMEDIA_TYPE_AUDIO:
748 frame_size = get_audio_frame_size(st->codec, pkt->size);
752 *pden = st->codec->sample_rate;
759 static int is_intra_only(AVCodecContext *enc){
760 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
762 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
763 switch(enc->codec_id){
765 case CODEC_ID_MJPEGB:
767 case CODEC_ID_RAWVIDEO:
768 case CODEC_ID_DVVIDEO:
769 case CODEC_ID_HUFFYUV:
770 case CODEC_ID_FFVHUFF:
775 case CODEC_ID_JPEG2000:
783 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
784 int64_t dts, int64_t pts)
786 AVStream *st= s->streams[stream_index];
787 AVPacketList *pktl= s->packet_buffer;
789 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
792 st->first_dts= dts - st->cur_dts;
795 for(; pktl; pktl= pktl->next){
796 if(pktl->pkt.stream_index != stream_index)
798 //FIXME think more about this check
799 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
800 pktl->pkt.pts += st->first_dts;
802 if(pktl->pkt.dts != AV_NOPTS_VALUE)
803 pktl->pkt.dts += st->first_dts;
805 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
806 st->start_time= pktl->pkt.pts;
808 if (st->start_time == AV_NOPTS_VALUE)
809 st->start_time = pts;
812 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
814 AVPacketList *pktl= s->packet_buffer;
817 if(st->first_dts != AV_NOPTS_VALUE){
818 cur_dts= st->first_dts;
819 for(; pktl; pktl= pktl->next){
820 if(pktl->pkt.stream_index == pkt->stream_index){
821 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
823 cur_dts -= pkt->duration;
826 pktl= s->packet_buffer;
827 st->first_dts = cur_dts;
828 }else if(st->cur_dts)
831 for(; pktl; pktl= pktl->next){
832 if(pktl->pkt.stream_index != pkt->stream_index)
834 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
835 && !pktl->pkt.duration){
836 pktl->pkt.dts= cur_dts;
837 if(!st->codec->has_b_frames)
838 pktl->pkt.pts= cur_dts;
839 cur_dts += pkt->duration;
840 pktl->pkt.duration= pkt->duration;
844 if(st->first_dts == AV_NOPTS_VALUE)
845 st->cur_dts= cur_dts;
848 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
849 AVCodecParserContext *pc, AVPacket *pkt)
851 int num, den, presentation_delayed, delay, i;
854 if (s->flags & AVFMT_FLAG_NOFILLIN)
857 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
858 pkt->dts= AV_NOPTS_VALUE;
860 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
861 //FIXME Set low_delay = 0 when has_b_frames = 1
862 st->codec->has_b_frames = 1;
864 /* do we have a video B-frame ? */
865 delay= st->codec->has_b_frames;
866 presentation_delayed = 0;
867 /* XXX: need has_b_frame, but cannot get it if the codec is
870 pc && pc->pict_type != FF_B_TYPE)
871 presentation_delayed = 1;
873 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
874 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
875 pkt->dts -= 1LL<<st->pts_wrap_bits;
878 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
879 // we take the conservative approach and discard both
880 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
881 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
882 av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
883 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
886 if (pkt->duration == 0) {
887 compute_frame_duration(&num, &den, st, pc, pkt);
889 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
891 if(pkt->duration != 0 && s->packet_buffer)
892 update_initial_durations(s, st, pkt);
896 /* correct timestamps with byte offset if demuxers only have timestamps
897 on packet boundaries */
898 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
899 /* this will estimate bitrate based on this frame's duration and size */
900 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
901 if(pkt->pts != AV_NOPTS_VALUE)
903 if(pkt->dts != AV_NOPTS_VALUE)
907 if (pc && pc->dts_sync_point >= 0) {
908 // we have synchronization info from the parser
909 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
911 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
912 if (pkt->dts != AV_NOPTS_VALUE) {
913 // got DTS from the stream, update reference timestamp
914 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
915 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
916 } else if (st->reference_dts != AV_NOPTS_VALUE) {
917 // compute DTS based on reference timestamp
918 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
919 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
921 if (pc->dts_sync_point > 0)
922 st->reference_dts = pkt->dts; // new reference
926 /* This may be redundant, but it should not hurt. */
927 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
928 presentation_delayed = 1;
930 // 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);
931 /* interpolate PTS and DTS if they are not present */
932 //We skip H264 currently because delay and has_b_frames are not reliably set
933 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
934 if (presentation_delayed) {
935 /* DTS = decompression timestamp */
936 /* PTS = presentation timestamp */
937 if (pkt->dts == AV_NOPTS_VALUE)
938 pkt->dts = st->last_IP_pts;
939 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
940 if (pkt->dts == AV_NOPTS_VALUE)
941 pkt->dts = st->cur_dts;
943 /* this is tricky: the dts must be incremented by the duration
944 of the frame we are displaying, i.e. the last I- or P-frame */
945 if (st->last_IP_duration == 0)
946 st->last_IP_duration = pkt->duration;
947 if(pkt->dts != AV_NOPTS_VALUE)
948 st->cur_dts = pkt->dts + st->last_IP_duration;
949 st->last_IP_duration = pkt->duration;
950 st->last_IP_pts= pkt->pts;
951 /* cannot compute PTS if not present (we can compute it only
952 by knowing the future */
953 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
954 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
955 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
956 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
957 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
958 pkt->pts += pkt->duration;
959 // 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);
963 /* presentation is not delayed : PTS and DTS are the same */
964 if(pkt->pts == AV_NOPTS_VALUE)
966 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
967 if(pkt->pts == AV_NOPTS_VALUE)
968 pkt->pts = st->cur_dts;
970 if(pkt->pts != AV_NOPTS_VALUE)
971 st->cur_dts = pkt->pts + pkt->duration;
975 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
976 st->pts_buffer[0]= pkt->pts;
977 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
978 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
979 if(pkt->dts == AV_NOPTS_VALUE)
980 pkt->dts= st->pts_buffer[0];
981 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
982 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
984 if(pkt->dts > st->cur_dts)
985 st->cur_dts = pkt->dts;
988 // 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);
991 if(is_intra_only(st->codec))
992 pkt->flags |= AV_PKT_FLAG_KEY;
995 /* keyframe computation */
996 if (pc->key_frame == 1)
997 pkt->flags |= AV_PKT_FLAG_KEY;
998 else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
999 pkt->flags |= AV_PKT_FLAG_KEY;
1002 pkt->convergence_duration = pc->convergence_duration;
1006 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1011 av_init_packet(pkt);
1014 /* select current input stream component */
1017 if (!st->need_parsing || !st->parser) {
1018 /* no parsing needed: we just output the packet as is */
1019 /* raw data support */
1020 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1021 compute_pkt_fields(s, st, NULL, pkt);
1023 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1024 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1025 ff_reduce_index(s, st->index);
1026 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1029 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1030 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1031 st->cur_ptr, st->cur_len,
1032 st->cur_pkt.pts, st->cur_pkt.dts,
1034 st->cur_pkt.pts = AV_NOPTS_VALUE;
1035 st->cur_pkt.dts = AV_NOPTS_VALUE;
1036 /* increment read pointer */
1040 /* return packet if any */
1044 pkt->stream_index = st->index;
1045 pkt->pts = st->parser->pts;
1046 pkt->dts = st->parser->dts;
1047 pkt->pos = st->parser->pos;
1048 pkt->destruct = NULL;
1049 compute_pkt_fields(s, st, st->parser, pkt);
1051 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1052 ff_reduce_index(s, st->index);
1053 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1054 0, 0, AVINDEX_KEYFRAME);
1061 av_free_packet(&st->cur_pkt);
1066 /* read next packet */
1067 ret = av_read_packet(s, &cur_pkt);
1069 if (ret == AVERROR(EAGAIN))
1071 /* return the last frames, if any */
1072 for(i = 0; i < s->nb_streams; i++) {
1074 if (st->parser && st->need_parsing) {
1075 av_parser_parse2(st->parser, st->codec,
1076 &pkt->data, &pkt->size,
1078 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1084 /* no more packets: really terminate parsing */
1087 st = s->streams[cur_pkt.stream_index];
1088 st->cur_pkt= cur_pkt;
1090 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1091 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1092 st->cur_pkt.pts < st->cur_pkt.dts){
1093 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1094 st->cur_pkt.stream_index,
1098 // av_free_packet(&st->cur_pkt);
1102 if(s->debug & FF_FDEBUG_TS)
1103 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1104 st->cur_pkt.stream_index,
1108 st->cur_pkt.duration,
1112 st->cur_ptr = st->cur_pkt.data;
1113 st->cur_len = st->cur_pkt.size;
1114 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1115 st->parser = av_parser_init(st->codec->codec_id);
1117 /* no parser available: just output the raw packets */
1118 st->need_parsing = AVSTREAM_PARSE_NONE;
1119 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1120 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1122 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1123 st->parser->next_frame_offset=
1124 st->parser->cur_offset= st->cur_pkt.pos;
1129 if(s->debug & FF_FDEBUG_TS)
1130 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1141 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1145 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1148 pktl = s->packet_buffer;
1150 AVPacket *next_pkt= &pktl->pkt;
1152 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1153 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1154 if( pktl->pkt.stream_index == next_pkt->stream_index
1155 && next_pkt->dts < pktl->pkt.dts
1156 && pktl->pkt.pts != pktl->pkt.dts //not b frame
1157 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1158 next_pkt->pts= pktl->pkt.dts;
1162 pktl = s->packet_buffer;
1165 if( next_pkt->pts != AV_NOPTS_VALUE
1166 || next_pkt->dts == AV_NOPTS_VALUE
1168 /* read packet from packet buffer, if there is data */
1170 s->packet_buffer = pktl->next;
1176 int ret= av_read_frame_internal(s, pkt);
1178 if(pktl && ret != AVERROR(EAGAIN)){
1185 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1186 &s->packet_buffer_end)) < 0)
1187 return AVERROR(ENOMEM);
1189 assert(!s->packet_buffer);
1190 return av_read_frame_internal(s, pkt);
1195 /* XXX: suppress the packet queue */
1196 static void flush_packet_queue(AVFormatContext *s)
1201 pktl = s->packet_buffer;
1204 s->packet_buffer = pktl->next;
1205 av_free_packet(&pktl->pkt);
1208 while(s->raw_packet_buffer){
1209 pktl = s->raw_packet_buffer;
1210 s->raw_packet_buffer = pktl->next;
1211 av_free_packet(&pktl->pkt);
1214 s->packet_buffer_end=
1215 s->raw_packet_buffer_end= NULL;
1216 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1219 /*******************************************************/
1222 int av_find_default_stream_index(AVFormatContext *s)
1224 int first_audio_index = -1;
1228 if (s->nb_streams <= 0)
1230 for(i = 0; i < s->nb_streams; i++) {
1232 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1235 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1236 first_audio_index = i;
1238 return first_audio_index >= 0 ? first_audio_index : 0;
1242 * Flush the frame reader.
1244 void ff_read_frame_flush(AVFormatContext *s)
1249 flush_packet_queue(s);
1253 /* for each stream, reset read state */
1254 for(i = 0; i < s->nb_streams; i++) {
1258 av_parser_close(st->parser);
1260 av_free_packet(&st->cur_pkt);
1262 st->last_IP_pts = AV_NOPTS_VALUE;
1263 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1264 st->reference_dts = AV_NOPTS_VALUE;
1269 st->probe_packets = MAX_PROBE_PACKETS;
1271 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1272 st->pts_buffer[j]= AV_NOPTS_VALUE;
1276 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1279 for(i = 0; i < s->nb_streams; i++) {
1280 AVStream *st = s->streams[i];
1282 st->cur_dts = av_rescale(timestamp,
1283 st->time_base.den * (int64_t)ref_st->time_base.num,
1284 st->time_base.num * (int64_t)ref_st->time_base.den);
1288 void ff_reduce_index(AVFormatContext *s, int stream_index)
1290 AVStream *st= s->streams[stream_index];
1291 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1293 if((unsigned)st->nb_index_entries >= max_entries){
1295 for(i=0; 2*i<st->nb_index_entries; i++)
1296 st->index_entries[i]= st->index_entries[2*i];
1297 st->nb_index_entries= i;
1301 int av_add_index_entry(AVStream *st,
1302 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1304 AVIndexEntry *entries, *ie;
1307 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1310 entries = av_fast_realloc(st->index_entries,
1311 &st->index_entries_allocated_size,
1312 (st->nb_index_entries + 1) *
1313 sizeof(AVIndexEntry));
1317 st->index_entries= entries;
1319 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1322 index= st->nb_index_entries++;
1323 ie= &entries[index];
1324 assert(index==0 || ie[-1].timestamp < timestamp);
1326 ie= &entries[index];
1327 if(ie->timestamp != timestamp){
1328 if(ie->timestamp <= timestamp)
1330 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1331 st->nb_index_entries++;
1332 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1333 distance= ie->min_distance;
1337 ie->timestamp = timestamp;
1338 ie->min_distance= distance;
1345 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1348 AVIndexEntry *entries= st->index_entries;
1349 int nb_entries= st->nb_index_entries;
1356 //optimize appending index entries at the end
1357 if(b && entries[b-1].timestamp < wanted_timestamp)
1362 timestamp = entries[m].timestamp;
1363 if(timestamp >= wanted_timestamp)
1365 if(timestamp <= wanted_timestamp)
1368 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1370 if(!(flags & AVSEEK_FLAG_ANY)){
1371 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1372 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1383 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1384 AVInputFormat *avif= s->iformat;
1385 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1386 int64_t ts_min, ts_max, ts;
1391 if (stream_index < 0)
1395 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1399 ts_min= AV_NOPTS_VALUE;
1400 pos_limit= -1; //gcc falsely says it may be uninitialized
1402 st= s->streams[stream_index];
1403 if(st->index_entries){
1406 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()
1407 index= FFMAX(index, 0);
1408 e= &st->index_entries[index];
1410 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1412 ts_min= e->timestamp;
1414 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1421 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1422 assert(index < st->nb_index_entries);
1424 e= &st->index_entries[index];
1425 assert(e->timestamp >= target_ts);
1427 ts_max= e->timestamp;
1428 pos_limit= pos_max - e->min_distance;
1430 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1431 pos_max,pos_limit, ts_max);
1436 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1441 if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1444 av_update_cur_dts(s, st, ts);
1449 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 )){
1451 int64_t start_pos, filesize;
1455 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1458 if(ts_min == AV_NOPTS_VALUE){
1459 pos_min = s->data_offset;
1460 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1461 if (ts_min == AV_NOPTS_VALUE)
1465 if(ts_max == AV_NOPTS_VALUE){
1467 filesize = url_fsize(s->pb);
1468 pos_max = filesize - 1;
1471 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1473 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1474 if (ts_max == AV_NOPTS_VALUE)
1478 int64_t tmp_pos= pos_max + 1;
1479 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1480 if(tmp_ts == AV_NOPTS_VALUE)
1484 if(tmp_pos >= filesize)
1490 if(ts_min > ts_max){
1492 }else if(ts_min == ts_max){
1497 while (pos_min < pos_limit) {
1499 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1503 assert(pos_limit <= pos_max);
1506 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1507 // interpolate position (better than dichotomy)
1508 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1509 + pos_min - approximate_keyframe_distance;
1510 }else if(no_change==1){
1511 // bisection, if interpolation failed to change min or max pos last time
1512 pos = (pos_min + pos_limit)>>1;
1514 /* linear search if bisection failed, can only happen if there
1515 are very few or no keyframes between min/max */
1520 else if(pos > pos_limit)
1524 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1530 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1531 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1532 start_pos, no_change);
1534 if(ts == AV_NOPTS_VALUE){
1535 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1538 assert(ts != AV_NOPTS_VALUE);
1539 if (target_ts <= ts) {
1540 pos_limit = start_pos - 1;
1544 if (target_ts >= ts) {
1550 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1551 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1554 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1556 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1557 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1558 pos, ts_min, target_ts, ts_max);
1564 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1565 int64_t pos_min, pos_max;
1569 if (stream_index < 0)
1572 st= s->streams[stream_index];
1575 pos_min = s->data_offset;
1576 pos_max = url_fsize(s->pb) - 1;
1578 if (pos < pos_min) pos= pos_min;
1579 else if(pos > pos_max) pos= pos_max;
1581 url_fseek(s->pb, pos, SEEK_SET);
1584 av_update_cur_dts(s, st, ts);
1589 static int av_seek_frame_generic(AVFormatContext *s,
1590 int stream_index, int64_t timestamp, int flags)
1597 st = s->streams[stream_index];
1599 index = av_index_search_timestamp(st, timestamp, flags);
1601 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1604 if(index < 0 || index==st->nb_index_entries-1){
1608 if(st->nb_index_entries){
1609 assert(st->index_entries);
1610 ie= &st->index_entries[st->nb_index_entries-1];
1611 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1613 av_update_cur_dts(s, st, ie->timestamp);
1615 if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1621 ret = av_read_frame(s, &pkt);
1622 }while(ret == AVERROR(EAGAIN));
1625 av_free_packet(&pkt);
1626 if(stream_index == pkt.stream_index){
1627 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1631 index = av_index_search_timestamp(st, timestamp, flags);
1636 ff_read_frame_flush(s);
1637 if (s->iformat->read_seek){
1638 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1641 ie = &st->index_entries[index];
1642 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1644 av_update_cur_dts(s, st, ie->timestamp);
1649 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1654 ff_read_frame_flush(s);
1656 if(flags & AVSEEK_FLAG_BYTE)
1657 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1659 if(stream_index < 0){
1660 stream_index= av_find_default_stream_index(s);
1661 if(stream_index < 0)
1664 st= s->streams[stream_index];
1665 /* timestamp for default must be expressed in AV_TIME_BASE units */
1666 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1669 /* first, we try the format specific seek */
1670 if (s->iformat->read_seek)
1671 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1678 if(s->iformat->read_timestamp)
1679 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1681 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1684 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1686 if(min_ts > ts || max_ts < ts)
1689 ff_read_frame_flush(s);
1691 if (s->iformat->read_seek2)
1692 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1694 if(s->iformat->read_timestamp){
1695 //try to seek via read_timestamp()
1698 //Fallback to old API if new is not implemented but old is
1699 //Note the old has somewat different sematics
1700 if(s->iformat->read_seek || 1)
1701 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1703 // try some generic seek like av_seek_frame_generic() but with new ts semantics
1706 /*******************************************************/
1709 * Returns TRUE if the stream has accurate duration in any stream.
1711 * @return TRUE if the stream has accurate duration for at least one component.
1713 static int av_has_duration(AVFormatContext *ic)
1718 for(i = 0;i < ic->nb_streams; i++) {
1719 st = ic->streams[i];
1720 if (st->duration != AV_NOPTS_VALUE)
1727 * Estimate the stream timings from the one of each components.
1729 * Also computes the global bitrate if possible.
1731 static void av_update_stream_timings(AVFormatContext *ic)
1733 int64_t start_time, start_time1, end_time, end_time1;
1734 int64_t duration, duration1;
1738 start_time = INT64_MAX;
1739 end_time = INT64_MIN;
1740 duration = INT64_MIN;
1741 for(i = 0;i < ic->nb_streams; i++) {
1742 st = ic->streams[i];
1743 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1744 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1745 if (start_time1 < start_time)
1746 start_time = start_time1;
1747 if (st->duration != AV_NOPTS_VALUE) {
1748 end_time1 = start_time1
1749 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1750 if (end_time1 > end_time)
1751 end_time = end_time1;
1754 if (st->duration != AV_NOPTS_VALUE) {
1755 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1756 if (duration1 > duration)
1757 duration = duration1;
1760 if (start_time != INT64_MAX) {
1761 ic->start_time = start_time;
1762 if (end_time != INT64_MIN) {
1763 if (end_time - start_time > duration)
1764 duration = end_time - start_time;
1767 if (duration != INT64_MIN) {
1768 ic->duration = duration;
1769 if (ic->file_size > 0) {
1770 /* compute the bitrate */
1771 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1772 (double)ic->duration;
1777 static void fill_all_stream_timings(AVFormatContext *ic)
1782 av_update_stream_timings(ic);
1783 for(i = 0;i < ic->nb_streams; i++) {
1784 st = ic->streams[i];
1785 if (st->start_time == AV_NOPTS_VALUE) {
1786 if(ic->start_time != AV_NOPTS_VALUE)
1787 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1788 if(ic->duration != AV_NOPTS_VALUE)
1789 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1794 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1796 int64_t filesize, duration;
1800 /* if bit_rate is already set, we believe it */
1801 if (ic->bit_rate == 0) {
1803 for(i=0;i<ic->nb_streams;i++) {
1804 st = ic->streams[i];
1805 bit_rate += st->codec->bit_rate;
1807 ic->bit_rate = bit_rate;
1810 /* if duration is already set, we believe it */
1811 if (ic->duration == AV_NOPTS_VALUE &&
1812 ic->bit_rate != 0 &&
1813 ic->file_size != 0) {
1814 filesize = ic->file_size;
1816 for(i = 0; i < ic->nb_streams; i++) {
1817 st = ic->streams[i];
1818 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1819 if (st->duration == AV_NOPTS_VALUE)
1820 st->duration = duration;
1826 #define DURATION_MAX_READ_SIZE 250000
1827 #define DURATION_MAX_RETRY 3
1829 /* only usable for MPEG-PS streams */
1830 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1832 AVPacket pkt1, *pkt = &pkt1;
1834 int read_size, i, ret;
1835 int64_t end_time, start_time[MAX_STREAMS];
1836 int64_t filesize, offset, duration;
1841 /* flush packet queue */
1842 flush_packet_queue(ic);
1844 for(i=0;i<ic->nb_streams;i++) {
1845 st = ic->streams[i];
1846 if(st->start_time != AV_NOPTS_VALUE){
1847 start_time[i]= st->start_time;
1848 }else if(st->first_dts != AV_NOPTS_VALUE){
1849 start_time[i]= st->first_dts;
1851 av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1854 av_parser_close(st->parser);
1856 av_free_packet(&st->cur_pkt);
1860 /* estimate the end time (duration) */
1861 /* XXX: may need to support wrapping */
1862 filesize = ic->file_size;
1863 end_time = AV_NOPTS_VALUE;
1865 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1869 url_fseek(ic->pb, offset, SEEK_SET);
1872 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1876 ret = av_read_packet(ic, pkt);
1877 }while(ret == AVERROR(EAGAIN));
1880 read_size += pkt->size;
1881 st = ic->streams[pkt->stream_index];
1882 if (pkt->pts != AV_NOPTS_VALUE &&
1883 start_time[pkt->stream_index] != AV_NOPTS_VALUE) {
1884 end_time = pkt->pts;
1885 duration = end_time - start_time[pkt->stream_index];
1887 duration += 1LL<<st->pts_wrap_bits;
1889 if (st->duration == AV_NOPTS_VALUE ||
1890 st->duration < duration)
1891 st->duration = duration;
1894 av_free_packet(pkt);
1896 }while( end_time==AV_NOPTS_VALUE
1897 && filesize > (DURATION_MAX_READ_SIZE<<retry)
1898 && ++retry <= DURATION_MAX_RETRY);
1900 fill_all_stream_timings(ic);
1902 url_fseek(ic->pb, old_offset, SEEK_SET);
1903 for(i=0; i<ic->nb_streams; i++){
1905 st->cur_dts= st->first_dts;
1906 st->last_IP_pts = AV_NOPTS_VALUE;
1910 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1914 /* get the file size, if possible */
1915 if (ic->iformat->flags & AVFMT_NOFILE) {
1918 file_size = url_fsize(ic->pb);
1922 ic->file_size = file_size;
1924 if ((!strcmp(ic->iformat->name, "mpeg") ||
1925 !strcmp(ic->iformat->name, "mpegts")) &&
1926 file_size && !url_is_streamed(ic->pb)) {
1927 /* get accurate estimate from the PTSes */
1928 av_estimate_timings_from_pts(ic, old_offset);
1929 } else if (av_has_duration(ic)) {
1930 /* at least one component has timings - we use them for all
1932 fill_all_stream_timings(ic);
1934 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1935 /* less precise: use bitrate info */
1936 av_estimate_timings_from_bit_rate(ic);
1938 av_update_stream_timings(ic);
1944 for(i = 0;i < ic->nb_streams; i++) {
1945 st = ic->streams[i];
1946 printf("%d: start_time: %0.3f duration: %0.3f\n",
1947 i, (double)st->start_time / AV_TIME_BASE,
1948 (double)st->duration / AV_TIME_BASE);
1950 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1951 (double)ic->start_time / AV_TIME_BASE,
1952 (double)ic->duration / AV_TIME_BASE,
1953 ic->bit_rate / 1000);
1958 static int has_codec_parameters(AVCodecContext *enc)
1961 switch(enc->codec_type) {
1962 case AVMEDIA_TYPE_AUDIO:
1963 val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1964 if(!enc->frame_size &&
1965 (enc->codec_id == CODEC_ID_VORBIS ||
1966 enc->codec_id == CODEC_ID_AAC ||
1967 enc->codec_id == CODEC_ID_MP1 ||
1968 enc->codec_id == CODEC_ID_MP2 ||
1969 enc->codec_id == CODEC_ID_MP3 ||
1970 enc->codec_id == CODEC_ID_SPEEX))
1973 case AVMEDIA_TYPE_VIDEO:
1974 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1980 return enc->codec_id != CODEC_ID_NONE && val != 0;
1983 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
1987 int got_picture, data_size, ret=0;
1990 if(!st->codec->codec){
1991 codec = avcodec_find_decoder(st->codec->codec_id);
1994 ret = avcodec_open(st->codec, codec);
1999 if(!has_codec_parameters(st->codec)){
2000 switch(st->codec->codec_type) {
2001 case AVMEDIA_TYPE_VIDEO:
2002 avcodec_get_frame_defaults(&picture);
2003 ret = avcodec_decode_video2(st->codec, &picture,
2004 &got_picture, avpkt);
2006 case AVMEDIA_TYPE_AUDIO:
2007 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2008 samples = av_malloc(data_size);
2011 ret = avcodec_decode_audio3(st->codec, samples,
2023 unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
2025 while (tags->id != CODEC_ID_NONE) {
2033 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2036 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2037 if(tag == tags[i].tag)
2040 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2041 if( toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
2042 && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
2043 && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
2044 && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
2047 return CODEC_ID_NONE;
2050 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2053 for(i=0; tags && tags[i]; i++){
2054 int tag= ff_codec_get_tag(tags[i], id);
2060 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2063 for(i=0; tags && tags[i]; i++){
2064 enum CodecID id= ff_codec_get_id(tags[i], tag);
2065 if(id!=CODEC_ID_NONE) return id;
2067 return CODEC_ID_NONE;
2070 static void compute_chapters_end(AVFormatContext *s)
2074 for (i=0; i+1<s->nb_chapters; i++)
2075 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2076 assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2077 assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2078 s->chapters[i]->end = s->chapters[i+1]->start;
2081 if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2082 assert(s->start_time != AV_NOPTS_VALUE);
2083 assert(s->duration > 0);
2084 s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2086 s->chapters[i]->time_base);
2090 #define MAX_STD_TIMEBASES (60*12+5)
2091 static int get_std_framerate(int i){
2092 if(i<60*12) return i*1001;
2093 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2097 * Is the time base unreliable.
2098 * This is a heuristic to balance between quick acceptance of the values in
2099 * the headers vs. some extra checks.
2100 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2101 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2102 * And there are "variable" fps files this needs to detect as well.
2104 static int tb_unreliable(AVCodecContext *c){
2105 if( c->time_base.den >= 101L*c->time_base.num
2106 || c->time_base.den < 5L*c->time_base.num
2107 /* || c->codec_tag == AV_RL32("DIVX")
2108 || c->codec_tag == AV_RL32("XVID")*/
2109 || c->codec_id == CODEC_ID_MPEG2VIDEO
2110 || c->codec_id == CODEC_ID_H264
2116 int av_find_stream_info(AVFormatContext *ic)
2118 int i, count, ret, read_size, j;
2120 AVPacket pkt1, *pkt;
2121 int64_t last_dts[MAX_STREAMS];
2122 int64_t duration_gcd[MAX_STREAMS]={0};
2123 int duration_count[MAX_STREAMS]={0};
2124 double (*duration_error)[MAX_STD_TIMEBASES];
2125 int64_t old_offset = url_ftell(ic->pb);
2126 int64_t codec_info_duration[MAX_STREAMS]={0};
2128 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2129 if (!duration_error) return AVERROR(ENOMEM);
2131 for(i=0;i<ic->nb_streams;i++) {
2132 st = ic->streams[i];
2133 if (st->codec->codec_id == CODEC_ID_AAC) {
2134 st->codec->sample_rate = 0;
2135 st->codec->frame_size = 0;
2136 st->codec->channels = 0;
2138 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
2139 /* if(!st->time_base.num)
2141 if(!st->codec->time_base.num)
2142 st->codec->time_base= st->time_base;
2144 //only for the split stuff
2145 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2146 st->parser = av_parser_init(st->codec->codec_id);
2147 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2148 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2151 assert(!st->codec->codec);
2152 //try to just open decoders, in case this is enough to get parameters
2153 if(!has_codec_parameters(st->codec)){
2154 AVCodec *codec = avcodec_find_decoder(st->codec->codec_id);
2156 avcodec_open(st->codec, codec);
2160 for(i=0;i<MAX_STREAMS;i++){
2161 last_dts[i]= AV_NOPTS_VALUE;
2167 if(url_interrupt_cb()){
2168 ret= AVERROR(EINTR);
2169 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2173 /* check if one codec still needs to be handled */
2174 for(i=0;i<ic->nb_streams;i++) {
2175 st = ic->streams[i];
2176 if (!has_codec_parameters(st->codec))
2178 /* variable fps and no guess at the real fps */
2179 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2180 && duration_count[i]<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2182 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2184 if(st->first_dts == AV_NOPTS_VALUE)
2187 if (i == ic->nb_streams) {
2188 /* NOTE: if the format has no header, then we need to read
2189 some packets to get most of the streams, so we cannot
2191 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2192 /* if we found the info for all the codecs, we can stop */
2194 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2198 /* we did not get all the codec info, but we read too much data */
2199 if (read_size >= ic->probesize) {
2201 av_log(ic, AV_LOG_WARNING, "MAX_READ_SIZE:%d reached\n", ic->probesize);
2205 /* NOTE: a new stream can be added there if no header in file
2206 (AVFMTCTX_NOHEADER) */
2207 ret = av_read_frame_internal(ic, &pkt1);
2208 if(ret == AVERROR(EAGAIN))
2212 ret = -1; /* we could not have all the codec parameters before EOF */
2213 for(i=0;i<ic->nb_streams;i++) {
2214 st = ic->streams[i];
2215 if (!has_codec_parameters(st->codec)){
2217 avcodec_string(buf, sizeof(buf), st->codec, 0);
2218 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2226 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2227 if(av_dup_packet(pkt) < 0) {
2228 av_free(duration_error);
2229 return AVERROR(ENOMEM);
2232 read_size += pkt->size;
2234 st = ic->streams[pkt->stream_index];
2235 if(st->codec_info_nb_frames>1) {
2236 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){
2237 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2240 codec_info_duration[st->index] += pkt->duration;
2242 st->codec_info_nb_frames++;
2245 int index= pkt->stream_index;
2246 int64_t last= last_dts[index];
2247 int64_t duration= pkt->dts - last;
2249 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2250 double dur= duration * av_q2d(st->time_base);
2252 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2253 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2254 if(duration_count[index] < 2)
2255 memset(duration_error[index], 0, sizeof(*duration_error));
2256 for(i=1; i<MAX_STD_TIMEBASES; i++){
2257 int framerate= get_std_framerate(i);
2258 int ticks= lrintf(dur*framerate/(1001*12));
2259 double error= dur - ticks*1001*12/(double)framerate;
2260 duration_error[index][i] += error*error;
2262 duration_count[index]++;
2263 // ignore the first 4 values, they might have some random jitter
2264 if (duration_count[index] > 3)
2265 duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2267 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2268 last_dts[pkt->stream_index]= pkt->dts;
2270 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2271 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2273 st->codec->extradata_size= i;
2274 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2275 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2276 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2280 /* if still no information, we try to open the codec and to
2281 decompress the frame. We try to avoid that in most cases as
2282 it takes longer and uses more memory. For MPEG-4, we need to
2283 decompress for QuickTime. */
2284 if (!has_codec_parameters(st->codec))
2285 try_decode_frame(st, pkt);
2290 // close codecs which were opened in try_decode_frame()
2291 for(i=0;i<ic->nb_streams;i++) {
2292 st = ic->streams[i];
2293 if(st->codec->codec)
2294 avcodec_close(st->codec);
2296 for(i=0;i<ic->nb_streams;i++) {
2297 st = ic->streams[i];
2298 if(st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && codec_info_duration[i])
2299 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2300 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2301 codec_info_duration[i] *(int64_t)st->time_base.num, 60000);
2302 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2303 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2304 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2306 // the check for tb_unreliable() is not completely correct, since this is not about handling
2307 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2308 // ipmovie.c produces.
2309 if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1 && !st->r_frame_rate.num)
2310 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);
2311 if(duration_count[i] && !st->r_frame_rate.num
2312 && tb_unreliable(st->codec) /*&&
2313 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2314 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2316 double best_error= 2*av_q2d(st->time_base);
2317 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2319 for(j=1; j<MAX_STD_TIMEBASES; j++){
2320 double error= duration_error[i][j] * get_std_framerate(j);
2321 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2322 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2323 if(error < best_error){
2325 num = get_std_framerate(j);
2328 // do not increase frame rate by more than 1 % in order to match a standard rate.
2329 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2330 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2333 if (!st->r_frame_rate.num){
2334 if( st->codec->time_base.den * (int64_t)st->time_base.num
2335 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2336 st->r_frame_rate.num = st->codec->time_base.den;
2337 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2339 st->r_frame_rate.num = st->time_base.den;
2340 st->r_frame_rate.den = st->time_base.num;
2343 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2344 if(!st->codec->bits_per_coded_sample)
2345 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2349 av_estimate_timings(ic, old_offset);
2351 compute_chapters_end(ic);
2354 /* correct DTS for B-frame streams with no timestamps */
2355 for(i=0;i<ic->nb_streams;i++) {
2356 st = ic->streams[i];
2357 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2359 ppktl = &ic->packet_buffer;
2361 if(ppkt1->stream_index != i)
2363 if(ppkt1->pkt->dts < 0)
2365 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2367 ppkt1->pkt->dts -= delta;
2372 st->cur_dts -= delta;
2378 av_free(duration_error);
2383 /*******************************************************/
2385 int av_read_play(AVFormatContext *s)
2387 if (s->iformat->read_play)
2388 return s->iformat->read_play(s);
2390 return av_url_read_fpause(s->pb, 0);
2391 return AVERROR(ENOSYS);
2394 int av_read_pause(AVFormatContext *s)
2396 if (s->iformat->read_pause)
2397 return s->iformat->read_pause(s);
2399 return av_url_read_fpause(s->pb, 1);
2400 return AVERROR(ENOSYS);
2403 void av_close_input_stream(AVFormatContext *s)
2408 if (s->iformat->read_close)
2409 s->iformat->read_close(s);
2410 for(i=0;i<s->nb_streams;i++) {
2411 /* free all data in a stream component */
2414 av_parser_close(st->parser);
2415 av_free_packet(&st->cur_pkt);
2417 av_metadata_free(&st->metadata);
2418 av_free(st->index_entries);
2419 av_free(st->codec->extradata);
2421 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2422 av_free(st->filename);
2424 av_free(st->priv_data);
2427 for(i=s->nb_programs-1; i>=0; i--) {
2428 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2429 av_freep(&s->programs[i]->provider_name);
2430 av_freep(&s->programs[i]->name);
2432 av_metadata_free(&s->programs[i]->metadata);
2433 av_freep(&s->programs[i]->stream_index);
2434 av_freep(&s->programs[i]);
2436 av_freep(&s->programs);
2437 flush_packet_queue(s);
2438 av_freep(&s->priv_data);
2439 while(s->nb_chapters--) {
2440 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2441 av_free(s->chapters[s->nb_chapters]->title);
2443 av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2444 av_free(s->chapters[s->nb_chapters]);
2446 av_freep(&s->chapters);
2447 av_metadata_free(&s->metadata);
2451 void av_close_input_file(AVFormatContext *s)
2453 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2454 av_close_input_stream(s);
2459 AVStream *av_new_stream(AVFormatContext *s, int id)
2464 if (s->nb_streams >= MAX_STREAMS)
2467 st = av_mallocz(sizeof(AVStream));
2471 st->codec= avcodec_alloc_context();
2473 /* no default bitrate if decoding */
2474 st->codec->bit_rate = 0;
2476 st->index = s->nb_streams;
2478 st->start_time = AV_NOPTS_VALUE;
2479 st->duration = AV_NOPTS_VALUE;
2480 /* we set the current DTS to 0 so that formats without any timestamps
2481 but durations get some timestamps, formats with some unknown
2482 timestamps have their first few packets buffered and the
2483 timestamps corrected before they are returned to the user */
2485 st->first_dts = AV_NOPTS_VALUE;
2486 st->probe_packets = MAX_PROBE_PACKETS;
2488 /* default pts setting is MPEG-like */
2489 av_set_pts_info(st, 33, 1, 90000);
2490 st->last_IP_pts = AV_NOPTS_VALUE;
2491 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2492 st->pts_buffer[i]= AV_NOPTS_VALUE;
2493 st->reference_dts = AV_NOPTS_VALUE;
2495 st->sample_aspect_ratio = (AVRational){0,1};
2497 s->streams[s->nb_streams++] = st;
2501 AVProgram *av_new_program(AVFormatContext *ac, int id)
2503 AVProgram *program=NULL;
2507 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2510 for(i=0; i<ac->nb_programs; i++)
2511 if(ac->programs[i]->id == id)
2512 program = ac->programs[i];
2515 program = av_mallocz(sizeof(AVProgram));
2518 dynarray_add(&ac->programs, &ac->nb_programs, program);
2519 program->discard = AVDISCARD_NONE;
2526 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2528 AVChapter *chapter = NULL;
2531 for(i=0; i<s->nb_chapters; i++)
2532 if(s->chapters[i]->id == id)
2533 chapter = s->chapters[i];
2536 chapter= av_mallocz(sizeof(AVChapter));
2539 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2541 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2542 av_free(chapter->title);
2544 av_metadata_set(&chapter->metadata, "title", title);
2546 chapter->time_base= time_base;
2547 chapter->start = start;
2553 /************************************************************/
2554 /* output media file */
2556 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2560 if (s->oformat->priv_data_size > 0) {
2561 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2563 return AVERROR(ENOMEM);
2565 s->priv_data = NULL;
2567 if (s->oformat->set_parameters) {
2568 ret = s->oformat->set_parameters(s, ap);
2575 int av_write_header(AVFormatContext *s)
2580 // some sanity checks
2581 if (s->nb_streams == 0) {
2582 av_log(s, AV_LOG_ERROR, "no streams\n");
2586 for(i=0;i<s->nb_streams;i++) {
2589 switch (st->codec->codec_type) {
2590 case AVMEDIA_TYPE_AUDIO:
2591 if(st->codec->sample_rate<=0){
2592 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2595 if(!st->codec->block_align)
2596 st->codec->block_align = st->codec->channels *
2597 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2599 case AVMEDIA_TYPE_VIDEO:
2600 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2601 av_log(s, AV_LOG_ERROR, "time base not set\n");
2604 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2605 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2608 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2609 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2615 if(s->oformat->codec_tag){
2616 if(st->codec->codec_tag){
2618 //check that tag + id is in the table
2619 //if neither is in the table -> OK
2620 //if tag is in the table with another id -> FAIL
2621 //if id is in the table with another tag -> FAIL unless strict < ?
2623 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2626 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2627 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2628 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2631 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2632 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2634 return AVERROR(ENOMEM);
2637 #if LIBAVFORMAT_VERSION_MAJOR < 53
2638 ff_metadata_mux_compat(s);
2641 /* set muxer identification string */
2642 if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2646 if (!(m = av_mallocz(sizeof(AVMetadata))))
2647 return AVERROR(ENOMEM);
2648 av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2649 metadata_conv(&m, s->oformat->metadata_conv, NULL);
2650 if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2651 av_metadata_set2(&s->metadata, t->key, t->value, 0);
2652 av_metadata_free(&m);
2655 if(s->oformat->write_header){
2656 ret = s->oformat->write_header(s);
2661 /* init PTS generation */
2662 for(i=0;i<s->nb_streams;i++) {
2663 int64_t den = AV_NOPTS_VALUE;
2666 switch (st->codec->codec_type) {
2667 case AVMEDIA_TYPE_AUDIO:
2668 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2670 case AVMEDIA_TYPE_VIDEO:
2671 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2676 if (den != AV_NOPTS_VALUE) {
2678 return AVERROR_INVALIDDATA;
2679 av_frac_init(&st->pts, 0, 0, den);
2685 //FIXME merge with compute_pkt_fields
2686 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2687 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2688 int num, den, frame_size, i;
2690 // 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);
2692 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2695 /* duration field */
2696 if (pkt->duration == 0) {
2697 compute_frame_duration(&num, &den, st, NULL, pkt);
2699 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2703 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2706 //XXX/FIXME this is a temporary hack until all encoders output pts
2707 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2709 // pkt->pts= st->cur_dts;
2710 pkt->pts= st->pts.val;
2713 //calculate dts from pts
2714 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2715 st->pts_buffer[0]= pkt->pts;
2716 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2717 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2718 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2719 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2721 pkt->dts= st->pts_buffer[0];
2724 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2725 av_log(s, AV_LOG_ERROR,
2726 "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2727 st->index, st->cur_dts, pkt->dts);
2730 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2731 av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2735 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2736 st->cur_dts= pkt->dts;
2737 st->pts.val= pkt->dts;
2740 switch (st->codec->codec_type) {
2741 case AVMEDIA_TYPE_AUDIO:
2742 frame_size = get_audio_frame_size(st->codec, pkt->size);
2744 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2745 likely equal to the encoder delay, but it would be better if we
2746 had the real timestamps from the encoder */
2747 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2748 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2751 case AVMEDIA_TYPE_VIDEO:
2752 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2760 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2762 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2764 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2767 ret= s->oformat->write_packet(s, pkt);
2769 ret= url_ferror(s->pb);
2773 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2774 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2776 AVPacketList **next_point, *this_pktl;
2778 this_pktl = av_mallocz(sizeof(AVPacketList));
2779 this_pktl->pkt= *pkt;
2780 pkt->destruct= NULL; // do not free original but only the copy
2781 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
2783 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2784 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2786 next_point = &s->packet_buffer;
2789 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2790 while(!compare(s, &(*next_point)->pkt, pkt)){
2791 next_point= &(*next_point)->next;
2795 next_point = &(s->packet_buffer_end->next);
2798 assert(!*next_point);
2800 s->packet_buffer_end= this_pktl;
2803 this_pktl->next= *next_point;
2805 s->streams[pkt->stream_index]->last_in_packet_buffer=
2806 *next_point= this_pktl;
2809 int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2811 AVStream *st = s->streams[ pkt ->stream_index];
2812 AVStream *st2= s->streams[ next->stream_index];
2813 int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2814 int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2815 return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2818 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2824 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2827 for(i=0; i < s->nb_streams; i++)
2828 stream_count+= !!s->streams[i]->last_in_packet_buffer;
2830 if(stream_count && (s->nb_streams == stream_count || flush)){
2831 pktl= s->packet_buffer;
2834 s->packet_buffer= pktl->next;
2835 if(!s->packet_buffer)
2836 s->packet_buffer_end= NULL;
2838 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2839 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2843 av_init_packet(out);
2849 * Interleaves an AVPacket correctly so it can be muxed.
2850 * @param out the interleaved packet will be output here
2851 * @param in the input packet
2852 * @param flush 1 if no further packets are available as input and all
2853 * remaining packets should be output
2854 * @return 1 if a packet was output, 0 if no packet could be output,
2855 * < 0 if an error occurred
2857 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2858 if(s->oformat->interleave_packet)
2859 return s->oformat->interleave_packet(s, out, in, flush);
2861 return av_interleave_packet_per_dts(s, out, in, flush);
2864 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2865 AVStream *st= s->streams[ pkt->stream_index];
2867 //FIXME/XXX/HACK drop zero sized packets
2868 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2871 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2872 if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2875 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2880 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2881 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2884 ret= s->oformat->write_packet(s, &opkt);
2886 av_free_packet(&opkt);
2891 if(url_ferror(s->pb))
2892 return url_ferror(s->pb);
2896 int av_write_trailer(AVFormatContext *s)
2902 ret= av_interleave_packet(s, &pkt, NULL, 1);
2903 if(ret<0) //FIXME cleanup needed for ret<0 ?
2908 ret= s->oformat->write_packet(s, &pkt);
2910 av_free_packet(&pkt);
2914 if(url_ferror(s->pb))
2918 if(s->oformat->write_trailer)
2919 ret = s->oformat->write_trailer(s);
2922 ret=url_ferror(s->pb);
2923 for(i=0;i<s->nb_streams;i++) {
2924 av_freep(&s->streams[i]->priv_data);
2925 av_freep(&s->streams[i]->index_entries);
2927 av_freep(&s->priv_data);
2931 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2934 AVProgram *program=NULL;
2937 if (idx >= ac->nb_streams) {
2938 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2942 for(i=0; i<ac->nb_programs; i++){
2943 if(ac->programs[i]->id != progid)
2945 program = ac->programs[i];
2946 for(j=0; j<program->nb_stream_indexes; j++)
2947 if(program->stream_index[j] == idx)
2950 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2953 program->stream_index = tmp;
2954 program->stream_index[program->nb_stream_indexes++] = idx;
2959 static void print_fps(double d, const char *postfix){
2960 uint64_t v= lrintf(d*100);
2961 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2962 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2963 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2966 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
2968 if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
2969 AVMetadataTag *tag=NULL;
2971 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2972 while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
2973 if(strcmp("language", tag->key))
2974 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
2979 /* "user interface" functions */
2980 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2983 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2984 AVStream *st = ic->streams[i];
2985 int g = av_gcd(st->time_base.num, st->time_base.den);
2986 AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
2987 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2988 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2989 /* the pid is an important information, so we display it */
2990 /* XXX: add a generic system */
2991 if (flags & AVFMT_SHOW_IDS)
2992 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2994 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2995 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
2996 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2997 if (st->sample_aspect_ratio.num && // default
2998 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
2999 AVRational display_aspect_ratio;
3000 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3001 st->codec->width*st->sample_aspect_ratio.num,
3002 st->codec->height*st->sample_aspect_ratio.den,
3004 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3005 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3006 display_aspect_ratio.num, display_aspect_ratio.den);
3008 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3009 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3010 print_fps(av_q2d(st->avg_frame_rate), "fps");
3011 if(st->r_frame_rate.den && st->r_frame_rate.num)
3012 print_fps(av_q2d(st->r_frame_rate), "tbr");
3013 if(st->time_base.den && st->time_base.num)
3014 print_fps(1/av_q2d(st->time_base), "tbn");
3015 if(st->codec->time_base.den && st->codec->time_base.num)
3016 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3018 av_log(NULL, AV_LOG_INFO, "\n");
3019 dump_metadata(NULL, st->metadata, " ");
3022 void dump_format(AVFormatContext *ic,
3028 uint8_t *printed = av_mallocz(ic->nb_streams);
3029 if (ic->nb_streams && !printed)
3032 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3033 is_output ? "Output" : "Input",
3035 is_output ? ic->oformat->name : ic->iformat->name,
3036 is_output ? "to" : "from", url);
3037 dump_metadata(NULL, ic->metadata, " ");
3039 av_log(NULL, AV_LOG_INFO, " Duration: ");
3040 if (ic->duration != AV_NOPTS_VALUE) {
3041 int hours, mins, secs, us;
3042 secs = ic->duration / AV_TIME_BASE;
3043 us = ic->duration % AV_TIME_BASE;
3048 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3049 (100 * us) / AV_TIME_BASE);
3051 av_log(NULL, AV_LOG_INFO, "N/A");
3053 if (ic->start_time != AV_NOPTS_VALUE) {
3055 av_log(NULL, AV_LOG_INFO, ", start: ");
3056 secs = ic->start_time / AV_TIME_BASE;
3057 us = ic->start_time % AV_TIME_BASE;
3058 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3059 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3061 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3063 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3065 av_log(NULL, AV_LOG_INFO, "N/A");
3067 av_log(NULL, AV_LOG_INFO, "\n");
3069 for (i = 0; i < ic->nb_chapters; i++) {
3070 AVChapter *ch = ic->chapters[i];
3071 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3072 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3073 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3075 dump_metadata(NULL, ch->metadata, " ");
3077 if(ic->nb_programs) {
3078 int j, k, total = 0;
3079 for(j=0; j<ic->nb_programs; j++) {
3080 AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3082 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3083 name ? name->value : "");
3084 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3085 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3086 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3087 printed[ic->programs[j]->stream_index[k]] = 1;
3089 total += ic->programs[j]->nb_stream_indexes;
3091 if (total < ic->nb_streams)
3092 av_log(NULL, AV_LOG_INFO, " No Program\n");
3094 for(i=0;i<ic->nb_streams;i++)
3096 dump_stream_format(ic, i, index, is_output);
3101 #if LIBAVFORMAT_VERSION_MAJOR < 53
3102 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3104 return av_parse_video_frame_size(width_ptr, height_ptr, str);
3107 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3109 AVRational frame_rate;
3110 int ret = av_parse_video_frame_rate(&frame_rate, arg);
3111 *frame_rate_num= frame_rate.num;
3112 *frame_rate_den= frame_rate.den;
3117 int64_t av_gettime(void)
3120 gettimeofday(&tv,NULL);
3121 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3124 uint64_t ff_ntp_time(void)
3126 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3129 int64_t parse_date(const char *datestr, int duration)
3135 static const char * const date_fmt[] = {
3139 static const char * const time_fmt[] = {
3149 time_t now = time(0);
3151 len = strlen(datestr);
3153 lastch = datestr[len - 1];
3156 is_utc = (lastch == 'z' || lastch == 'Z');
3158 memset(&dt, 0, sizeof(dt));
3163 if (!strncasecmp(datestr, "now", len))
3164 return (int64_t) now * 1000000;
3166 /* parse the year-month-day part */
3167 for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3168 q = small_strptime(p, date_fmt[i], &dt);
3174 /* if the year-month-day part is missing, then take the
3175 * current year-month-day time */
3180 dt = *localtime(&now);
3182 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3187 if (*p == 'T' || *p == 't' || *p == ' ')
3190 /* parse the hour-minute-second part */
3191 for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3192 q = small_strptime(p, time_fmt[i], &dt);
3198 /* parse datestr as a duration */
3203 /* parse datestr as HH:MM:SS */
3204 q = small_strptime(p, time_fmt[0], &dt);
3206 /* parse datestr as S+ */
3207 dt.tm_sec = strtol(p, (char **)&q, 10);
3209 /* the parsing didn't succeed */
3216 /* Now we have all the fields that we can get */
3222 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3224 dt.tm_isdst = -1; /* unknown */
3234 /* parse the .m... part */
3238 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3241 val += n * (*q - '0');
3245 return negative ? -t : t;
3248 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3258 while (*p != '\0' && *p != '=' && *p != '&') {
3259 if ((q - tag) < sizeof(tag) - 1)
3267 while (*p != '&' && *p != '\0') {
3268 if ((q - arg) < arg_size - 1) {
3278 if (!strcmp(tag, tag1))
3287 int av_get_frame_filename(char *buf, int buf_size,
3288 const char *path, int number)
3291 char *q, buf1[20], c;
3292 int nd, len, percentd_found;
3304 while (isdigit(*p)) {
3305 nd = nd * 10 + *p++ - '0';
3308 } while (isdigit(c));
3317 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3319 if ((q - buf + len) > buf_size - 1)
3321 memcpy(q, buf1, len);
3329 if ((q - buf) < buf_size - 1)
3333 if (!percentd_found)
3342 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3346 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3348 for(i=0;i<size;i+=16) {
3355 PRINT(" %02x", buf[i+j]);
3360 for(j=0;j<len;j++) {
3362 if (c < ' ' || c > '~')
3371 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3373 hex_dump_internal(NULL, f, 0, buf, size);
3376 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3378 hex_dump_internal(avcl, NULL, level, buf, size);
3381 //FIXME needs to know the time_base
3382 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3385 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3386 PRINT("stream #%d:\n", pkt->stream_index);
3387 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3388 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3389 /* DTS is _always_ valid after av_read_frame() */
3391 if (pkt->dts == AV_NOPTS_VALUE)
3394 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3395 /* PTS may not be known if B-frames are present. */
3397 if (pkt->pts == AV_NOPTS_VALUE)
3400 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3402 PRINT(" size=%d\n", pkt->size);
3405 av_hex_dump(f, pkt->data, pkt->size);
3408 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3410 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3413 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3415 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3418 void ff_url_split(char *proto, int proto_size,
3419 char *authorization, int authorization_size,
3420 char *hostname, int hostname_size,
3422 char *path, int path_size,
3425 const char *p, *ls, *at, *col, *brk;
3427 if (port_ptr) *port_ptr = -1;
3428 if (proto_size > 0) proto[0] = 0;
3429 if (authorization_size > 0) authorization[0] = 0;
3430 if (hostname_size > 0) hostname[0] = 0;
3431 if (path_size > 0) path[0] = 0;
3433 /* parse protocol */
3434 if ((p = strchr(url, ':'))) {
3435 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3440 /* no protocol means plain filename */
3441 av_strlcpy(path, url, path_size);
3445 /* separate path from hostname */
3446 ls = strchr(p, '/');
3448 ls = strchr(p, '?');
3450 av_strlcpy(path, ls, path_size);
3452 ls = &p[strlen(p)]; // XXX
3454 /* the rest is hostname, use that to parse auth/port */
3456 /* authorization (user[:pass]@hostname) */
3457 if ((at = strchr(p, '@')) && at < ls) {
3458 av_strlcpy(authorization, p,
3459 FFMIN(authorization_size, at + 1 - p));
3460 p = at + 1; /* skip '@' */
3463 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3465 av_strlcpy(hostname, p + 1,
3466 FFMIN(hostname_size, brk - p));
3467 if (brk[1] == ':' && port_ptr)
3468 *port_ptr = atoi(brk + 2);
3469 } else if ((col = strchr(p, ':')) && col < ls) {
3470 av_strlcpy(hostname, p,
3471 FFMIN(col + 1 - p, hostname_size));
3472 if (port_ptr) *port_ptr = atoi(col + 1);
3474 av_strlcpy(hostname, p,
3475 FFMIN(ls + 1 - p, hostname_size));
3479 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3482 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3485 'C', 'D', 'E', 'F' };
3486 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3489 'c', 'd', 'e', 'f' };
3490 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3492 for(i = 0; i < s; i++) {
3493 buff[i * 2] = hex_table[src[i] >> 4];
3494 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3500 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3501 unsigned int pts_num, unsigned int pts_den)
3503 s->pts_wrap_bits = pts_wrap_bits;
3505 if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3506 if(s->time_base.num != pts_num)
3507 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3509 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3511 if(!s->time_base.num || !s->time_base.den)
3512 s->time_base.num= s->time_base.den= 0;
3515 int ff_url_join(char *str, int size, const char *proto,
3516 const char *authorization, const char *hostname,
3517 int port, const char *fmt, ...)
3520 struct addrinfo hints, *ai;
3525 av_strlcatf(str, size, "%s://", proto);
3527 av_strlcatf(str, size, "%s@", authorization);
3528 #if CONFIG_NETWORK && defined(AF_INET6)
3529 /* Determine if hostname is a numerical IPv6 address,
3530 * properly escape it within [] in that case. */
3531 memset(&hints, 0, sizeof(hints));
3532 hints.ai_flags = AI_NUMERICHOST;
3533 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3534 if (ai->ai_family == AF_INET6) {
3535 av_strlcat(str, "[", size);
3536 av_strlcat(str, hostname, size);
3537 av_strlcat(str, "]", size);
3539 av_strlcat(str, hostname, size);
3544 /* Not an IPv6 address, just output the plain string. */
3545 av_strlcat(str, hostname, size);
3548 av_strlcatf(str, size, ":%d", port);
3551 int len = strlen(str);
3554 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);