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);
521 return AVERROR_INVALIDDATA;
524 /* rewind. reuse probe buffer to avoid seeking */
525 if ((ret = ff_rewind_with_probe_data(*pb, buf, pd.buf_size)) < 0)
531 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
534 AVFormatParameters *ap)
537 AVProbeData probe_data, *pd = &probe_data;
538 ByteIOContext *pb = NULL;
539 void *logctx= ap && ap->prealloced_context ? *ic_ptr : NULL;
543 pd->filename = filename;
548 /* guess format if no file can be opened */
549 fmt = av_probe_input_format(pd, 0);
552 /* Do not open file if the format does not need it. XXX: specific
553 hack needed to handle RTSP/TCP */
554 if (!fmt || !(fmt->flags & AVFMT_NOFILE)) {
555 /* if no file needed do not try to open one */
556 if ((err=url_fopen(&pb, filename, URL_RDONLY)) < 0) {
560 url_setbufsize(pb, buf_size);
562 if (!fmt && (err = ff_probe_input_buffer(&pb, &fmt, filename, logctx, 0, logctx ? (*ic_ptr)->probesize : 0)) < 0) {
567 /* if still no format found, error */
569 err = AVERROR_INVALIDDATA;
573 /* check filename in case an image number is expected */
574 if (fmt->flags & AVFMT_NEEDNUMBER) {
575 if (!av_filename_number_test(filename)) {
576 err = AVERROR_NUMEXPECTED;
580 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
588 if (ap && ap->prealloced_context)
595 /*******************************************************/
597 static AVPacket *add_to_pktbuf(AVPacketList **packet_buffer, AVPacket *pkt,
598 AVPacketList **plast_pktl){
599 AVPacketList *pktl = av_mallocz(sizeof(AVPacketList));
604 (*plast_pktl)->next = pktl;
606 *packet_buffer = pktl;
608 /* add the packet in the buffered packet list */
614 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
620 AVPacketList *pktl = s->raw_packet_buffer;
624 if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
625 !s->streams[pkt->stream_index]->probe_packets ||
626 s->raw_packet_buffer_remaining_size < pkt->size){
627 AVProbeData *pd = &s->streams[pkt->stream_index]->probe_data;
630 s->raw_packet_buffer = pktl->next;
631 s->raw_packet_buffer_remaining_size += pkt->size;
638 ret= s->iformat->read_packet(s, pkt);
640 if (!pktl || ret == AVERROR(EAGAIN))
642 for (i = 0; i < s->nb_streams; i++)
643 s->streams[i]->probe_packets = 0;
646 st= s->streams[pkt->stream_index];
648 switch(st->codec->codec_type){
649 case AVMEDIA_TYPE_VIDEO:
650 if(s->video_codec_id) st->codec->codec_id= s->video_codec_id;
652 case AVMEDIA_TYPE_AUDIO:
653 if(s->audio_codec_id) st->codec->codec_id= s->audio_codec_id;
655 case AVMEDIA_TYPE_SUBTITLE:
656 if(s->subtitle_codec_id)st->codec->codec_id= s->subtitle_codec_id;
660 if(!pktl && (st->codec->codec_id != CODEC_ID_PROBE ||
664 add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
665 s->raw_packet_buffer_remaining_size -= pkt->size;
667 if(st->codec->codec_id == CODEC_ID_PROBE){
668 AVProbeData *pd = &st->probe_data;
669 av_log(s, AV_LOG_DEBUG, "probing stream %d\n", st->index);
672 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
673 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
674 pd->buf_size += pkt->size;
675 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
677 if(av_log2(pd->buf_size) != av_log2(pd->buf_size - pkt->size)){
678 //FIXME we dont reduce score to 0 for the case of running out of buffer space in bytes
679 set_codec_from_probe_data(s, st, pd, st->probe_packets > 0 ? AVPROBE_SCORE_MAX/4 : 0);
680 if(st->codec->codec_id != CODEC_ID_PROBE){
683 av_log(s, AV_LOG_DEBUG, "probed stream %d\n", st->index);
690 /**********************************************************/
693 * Get the number of samples of an audio frame. Return -1 on error.
695 static int get_audio_frame_size(AVCodecContext *enc, int size)
699 if(enc->codec_id == CODEC_ID_VORBIS)
702 if (enc->frame_size <= 1) {
703 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
705 if (bits_per_sample) {
706 if (enc->channels == 0)
708 frame_size = (size << 3) / (bits_per_sample * enc->channels);
710 /* used for example by ADPCM codecs */
711 if (enc->bit_rate == 0)
713 frame_size = ((int64_t)size * 8 * enc->sample_rate) / enc->bit_rate;
716 frame_size = enc->frame_size;
723 * Return the frame duration in seconds. Return 0 if not available.
725 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
726 AVCodecParserContext *pc, AVPacket *pkt)
732 switch(st->codec->codec_type) {
733 case AVMEDIA_TYPE_VIDEO:
734 if(st->time_base.num*1000LL > st->time_base.den){
735 *pnum = st->time_base.num;
736 *pden = st->time_base.den;
737 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
738 *pnum = st->codec->time_base.num;
739 *pden = st->codec->time_base.den;
740 if (pc && pc->repeat_pict) {
741 *pnum = (*pnum) * (1 + pc->repeat_pict);
743 //If this codec can be interlaced or progressive then we need a parser to compute duration of a packet
744 //Thus if we have no parser in such case leave duration undefined.
745 if(st->codec->ticks_per_frame>1 && !pc){
750 case AVMEDIA_TYPE_AUDIO:
751 frame_size = get_audio_frame_size(st->codec, pkt->size);
755 *pden = st->codec->sample_rate;
762 static int is_intra_only(AVCodecContext *enc){
763 if(enc->codec_type == AVMEDIA_TYPE_AUDIO){
765 }else if(enc->codec_type == AVMEDIA_TYPE_VIDEO){
766 switch(enc->codec_id){
768 case CODEC_ID_MJPEGB:
770 case CODEC_ID_RAWVIDEO:
771 case CODEC_ID_DVVIDEO:
772 case CODEC_ID_HUFFYUV:
773 case CODEC_ID_FFVHUFF:
778 case CODEC_ID_JPEG2000:
786 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
787 int64_t dts, int64_t pts)
789 AVStream *st= s->streams[stream_index];
790 AVPacketList *pktl= s->packet_buffer;
792 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE || st->cur_dts == AV_NOPTS_VALUE)
795 st->first_dts= dts - st->cur_dts;
798 for(; pktl; pktl= pktl->next){
799 if(pktl->pkt.stream_index != stream_index)
801 //FIXME think more about this check
802 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
803 pktl->pkt.pts += st->first_dts;
805 if(pktl->pkt.dts != AV_NOPTS_VALUE)
806 pktl->pkt.dts += st->first_dts;
808 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
809 st->start_time= pktl->pkt.pts;
811 if (st->start_time == AV_NOPTS_VALUE)
812 st->start_time = pts;
815 static void update_initial_durations(AVFormatContext *s, AVStream *st, AVPacket *pkt)
817 AVPacketList *pktl= s->packet_buffer;
820 if(st->first_dts != AV_NOPTS_VALUE){
821 cur_dts= st->first_dts;
822 for(; pktl; pktl= pktl->next){
823 if(pktl->pkt.stream_index == pkt->stream_index){
824 if(pktl->pkt.pts != pktl->pkt.dts || pktl->pkt.dts != AV_NOPTS_VALUE || pktl->pkt.duration)
826 cur_dts -= pkt->duration;
829 pktl= s->packet_buffer;
830 st->first_dts = cur_dts;
831 }else if(st->cur_dts)
834 for(; pktl; pktl= pktl->next){
835 if(pktl->pkt.stream_index != pkt->stream_index)
837 if(pktl->pkt.pts == pktl->pkt.dts && pktl->pkt.dts == AV_NOPTS_VALUE
838 && !pktl->pkt.duration){
839 pktl->pkt.dts= cur_dts;
840 if(!st->codec->has_b_frames)
841 pktl->pkt.pts= cur_dts;
842 cur_dts += pkt->duration;
843 pktl->pkt.duration= pkt->duration;
847 if(st->first_dts == AV_NOPTS_VALUE)
848 st->cur_dts= cur_dts;
851 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
852 AVCodecParserContext *pc, AVPacket *pkt)
854 int num, den, presentation_delayed, delay, i;
857 if (s->flags & AVFMT_FLAG_NOFILLIN)
860 if((s->flags & AVFMT_FLAG_IGNDTS) && pkt->pts != AV_NOPTS_VALUE)
861 pkt->dts= AV_NOPTS_VALUE;
863 if (st->codec->codec_id != CODEC_ID_H264 && pc && pc->pict_type == FF_B_TYPE)
864 //FIXME Set low_delay = 0 when has_b_frames = 1
865 st->codec->has_b_frames = 1;
867 /* do we have a video B-frame ? */
868 delay= st->codec->has_b_frames;
869 presentation_delayed = 0;
870 /* XXX: need has_b_frame, but cannot get it if the codec is
873 pc && pc->pict_type != FF_B_TYPE)
874 presentation_delayed = 1;
876 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
877 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
878 pkt->dts -= 1LL<<st->pts_wrap_bits;
881 // some mpeg2 in mpeg-ps lack dts (issue171 / input_file.mpg)
882 // we take the conservative approach and discard both
883 // Note, if this is misbehaving for a H.264 file then possibly presentation_delayed is not set correctly.
884 if(delay==1 && pkt->dts == pkt->pts && pkt->dts != AV_NOPTS_VALUE && presentation_delayed){
885 av_log(s, AV_LOG_WARNING, "invalid dts/pts combination\n");
886 pkt->dts= pkt->pts= AV_NOPTS_VALUE;
889 if (pkt->duration == 0) {
890 compute_frame_duration(&num, &den, st, pc, pkt);
892 pkt->duration = av_rescale_rnd(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num, AV_ROUND_DOWN);
894 if(pkt->duration != 0 && s->packet_buffer)
895 update_initial_durations(s, st, pkt);
899 /* correct timestamps with byte offset if demuxers only have timestamps
900 on packet boundaries */
901 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
902 /* this will estimate bitrate based on this frame's duration and size */
903 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
904 if(pkt->pts != AV_NOPTS_VALUE)
906 if(pkt->dts != AV_NOPTS_VALUE)
910 if (pc && pc->dts_sync_point >= 0) {
911 // we have synchronization info from the parser
912 int64_t den = st->codec->time_base.den * (int64_t) st->time_base.num;
914 int64_t num = st->codec->time_base.num * (int64_t) st->time_base.den;
915 if (pkt->dts != AV_NOPTS_VALUE) {
916 // got DTS from the stream, update reference timestamp
917 st->reference_dts = pkt->dts - pc->dts_ref_dts_delta * num / den;
918 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
919 } else if (st->reference_dts != AV_NOPTS_VALUE) {
920 // compute DTS based on reference timestamp
921 pkt->dts = st->reference_dts + pc->dts_ref_dts_delta * num / den;
922 pkt->pts = pkt->dts + pc->pts_dts_delta * num / den;
924 if (pc->dts_sync_point > 0)
925 st->reference_dts = pkt->dts; // new reference
929 /* This may be redundant, but it should not hurt. */
930 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
931 presentation_delayed = 1;
933 // 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);
934 /* interpolate PTS and DTS if they are not present */
935 //We skip H264 currently because delay and has_b_frames are not reliably set
936 if((delay==0 || (delay==1 && pc)) && st->codec->codec_id != CODEC_ID_H264){
937 if (presentation_delayed) {
938 /* DTS = decompression timestamp */
939 /* PTS = presentation timestamp */
940 if (pkt->dts == AV_NOPTS_VALUE)
941 pkt->dts = st->last_IP_pts;
942 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
943 if (pkt->dts == AV_NOPTS_VALUE)
944 pkt->dts = st->cur_dts;
946 /* this is tricky: the dts must be incremented by the duration
947 of the frame we are displaying, i.e. the last I- or P-frame */
948 if (st->last_IP_duration == 0)
949 st->last_IP_duration = pkt->duration;
950 if(pkt->dts != AV_NOPTS_VALUE)
951 st->cur_dts = pkt->dts + st->last_IP_duration;
952 st->last_IP_duration = pkt->duration;
953 st->last_IP_pts= pkt->pts;
954 /* cannot compute PTS if not present (we can compute it only
955 by knowing the future */
956 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
957 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
958 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
959 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
960 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
961 pkt->pts += pkt->duration;
962 // 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);
966 /* presentation is not delayed : PTS and DTS are the same */
967 if(pkt->pts == AV_NOPTS_VALUE)
969 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
970 if(pkt->pts == AV_NOPTS_VALUE)
971 pkt->pts = st->cur_dts;
973 if(pkt->pts != AV_NOPTS_VALUE)
974 st->cur_dts = pkt->pts + pkt->duration;
978 if(pkt->pts != AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
979 st->pts_buffer[0]= pkt->pts;
980 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
981 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
982 if(pkt->dts == AV_NOPTS_VALUE)
983 pkt->dts= st->pts_buffer[0];
984 if(st->codec->codec_id == CODEC_ID_H264){ //we skiped it above so we try here
985 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
987 if(pkt->dts > st->cur_dts)
988 st->cur_dts = pkt->dts;
991 // 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);
994 if(is_intra_only(st->codec))
995 pkt->flags |= AV_PKT_FLAG_KEY;
998 /* keyframe computation */
999 if (pc->key_frame == 1)
1000 pkt->flags |= AV_PKT_FLAG_KEY;
1001 else if (pc->key_frame == -1 && pc->pict_type == FF_I_TYPE)
1002 pkt->flags |= AV_PKT_FLAG_KEY;
1005 pkt->convergence_duration = pc->convergence_duration;
1009 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
1014 av_init_packet(pkt);
1017 /* select current input stream component */
1020 if (!st->need_parsing || !st->parser) {
1021 /* no parsing needed: we just output the packet as is */
1022 /* raw data support */
1023 *pkt = st->cur_pkt; st->cur_pkt.data= NULL;
1024 compute_pkt_fields(s, st, NULL, pkt);
1026 if ((s->iformat->flags & AVFMT_GENERIC_INDEX) &&
1027 (pkt->flags & AV_PKT_FLAG_KEY) && pkt->dts != AV_NOPTS_VALUE) {
1028 ff_reduce_index(s, st->index);
1029 av_add_index_entry(st, pkt->pos, pkt->dts, 0, 0, AVINDEX_KEYFRAME);
1032 } else if (st->cur_len > 0 && st->discard < AVDISCARD_ALL) {
1033 len = av_parser_parse2(st->parser, st->codec, &pkt->data, &pkt->size,
1034 st->cur_ptr, st->cur_len,
1035 st->cur_pkt.pts, st->cur_pkt.dts,
1037 st->cur_pkt.pts = AV_NOPTS_VALUE;
1038 st->cur_pkt.dts = AV_NOPTS_VALUE;
1039 /* increment read pointer */
1043 /* return packet if any */
1047 pkt->stream_index = st->index;
1048 pkt->pts = st->parser->pts;
1049 pkt->dts = st->parser->dts;
1050 pkt->pos = st->parser->pos;
1051 pkt->destruct = NULL;
1052 compute_pkt_fields(s, st, st->parser, pkt);
1054 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & AV_PKT_FLAG_KEY){
1055 ff_reduce_index(s, st->index);
1056 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
1057 0, 0, AVINDEX_KEYFRAME);
1064 av_free_packet(&st->cur_pkt);
1069 /* read next packet */
1070 ret = av_read_packet(s, &cur_pkt);
1072 if (ret == AVERROR(EAGAIN))
1074 /* return the last frames, if any */
1075 for(i = 0; i < s->nb_streams; i++) {
1077 if (st->parser && st->need_parsing) {
1078 av_parser_parse2(st->parser, st->codec,
1079 &pkt->data, &pkt->size,
1081 AV_NOPTS_VALUE, AV_NOPTS_VALUE,
1087 /* no more packets: really terminate parsing */
1090 st = s->streams[cur_pkt.stream_index];
1091 st->cur_pkt= cur_pkt;
1093 if(st->cur_pkt.pts != AV_NOPTS_VALUE &&
1094 st->cur_pkt.dts != AV_NOPTS_VALUE &&
1095 st->cur_pkt.pts < st->cur_pkt.dts){
1096 av_log(s, AV_LOG_WARNING, "Invalid timestamps stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
1097 st->cur_pkt.stream_index,
1101 // av_free_packet(&st->cur_pkt);
1105 if(s->debug & FF_FDEBUG_TS)
1106 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1107 st->cur_pkt.stream_index,
1111 st->cur_pkt.duration,
1115 st->cur_ptr = st->cur_pkt.data;
1116 st->cur_len = st->cur_pkt.size;
1117 if (st->need_parsing && !st->parser && !(s->flags & AVFMT_FLAG_NOPARSE)) {
1118 st->parser = av_parser_init(st->codec->codec_id);
1120 /* no parser available: just output the raw packets */
1121 st->need_parsing = AVSTREAM_PARSE_NONE;
1122 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
1123 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1125 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
1126 st->parser->next_frame_offset=
1127 st->parser->cur_offset= st->cur_pkt.pos;
1132 if(s->debug & FF_FDEBUG_TS)
1133 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d, duration=%d, flags=%d\n",
1144 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
1148 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
1151 pktl = s->packet_buffer;
1153 AVPacket *next_pkt= &pktl->pkt;
1155 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
1156 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
1157 if( pktl->pkt.stream_index == next_pkt->stream_index
1158 && next_pkt->dts < pktl->pkt.dts
1159 && pktl->pkt.pts != pktl->pkt.dts //not b frame
1160 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
1161 next_pkt->pts= pktl->pkt.dts;
1165 pktl = s->packet_buffer;
1168 if( next_pkt->pts != AV_NOPTS_VALUE
1169 || next_pkt->dts == AV_NOPTS_VALUE
1171 /* read packet from packet buffer, if there is data */
1173 s->packet_buffer = pktl->next;
1179 int ret= av_read_frame_internal(s, pkt);
1181 if(pktl && ret != AVERROR(EAGAIN)){
1188 if(av_dup_packet(add_to_pktbuf(&s->packet_buffer, pkt,
1189 &s->packet_buffer_end)) < 0)
1190 return AVERROR(ENOMEM);
1192 assert(!s->packet_buffer);
1193 return av_read_frame_internal(s, pkt);
1198 /* XXX: suppress the packet queue */
1199 static void flush_packet_queue(AVFormatContext *s)
1204 pktl = s->packet_buffer;
1207 s->packet_buffer = pktl->next;
1208 av_free_packet(&pktl->pkt);
1211 while(s->raw_packet_buffer){
1212 pktl = s->raw_packet_buffer;
1213 s->raw_packet_buffer = pktl->next;
1214 av_free_packet(&pktl->pkt);
1217 s->packet_buffer_end=
1218 s->raw_packet_buffer_end= NULL;
1219 s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
1222 /*******************************************************/
1225 int av_find_default_stream_index(AVFormatContext *s)
1227 int first_audio_index = -1;
1231 if (s->nb_streams <= 0)
1233 for(i = 0; i < s->nb_streams; i++) {
1235 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1238 if (first_audio_index < 0 && st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1239 first_audio_index = i;
1241 return first_audio_index >= 0 ? first_audio_index : 0;
1245 * Flush the frame reader.
1247 void ff_read_frame_flush(AVFormatContext *s)
1252 flush_packet_queue(s);
1256 /* for each stream, reset read state */
1257 for(i = 0; i < s->nb_streams; i++) {
1261 av_parser_close(st->parser);
1263 av_free_packet(&st->cur_pkt);
1265 st->last_IP_pts = AV_NOPTS_VALUE;
1266 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
1267 st->reference_dts = AV_NOPTS_VALUE;
1272 st->probe_packets = MAX_PROBE_PACKETS;
1274 for(j=0; j<MAX_REORDER_DELAY+1; j++)
1275 st->pts_buffer[j]= AV_NOPTS_VALUE;
1279 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
1282 for(i = 0; i < s->nb_streams; i++) {
1283 AVStream *st = s->streams[i];
1285 st->cur_dts = av_rescale(timestamp,
1286 st->time_base.den * (int64_t)ref_st->time_base.num,
1287 st->time_base.num * (int64_t)ref_st->time_base.den);
1291 void ff_reduce_index(AVFormatContext *s, int stream_index)
1293 AVStream *st= s->streams[stream_index];
1294 unsigned int max_entries= s->max_index_size / sizeof(AVIndexEntry);
1296 if((unsigned)st->nb_index_entries >= max_entries){
1298 for(i=0; 2*i<st->nb_index_entries; i++)
1299 st->index_entries[i]= st->index_entries[2*i];
1300 st->nb_index_entries= i;
1304 int av_add_index_entry(AVStream *st,
1305 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1307 AVIndexEntry *entries, *ie;
1310 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1313 entries = av_fast_realloc(st->index_entries,
1314 &st->index_entries_allocated_size,
1315 (st->nb_index_entries + 1) *
1316 sizeof(AVIndexEntry));
1320 st->index_entries= entries;
1322 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1325 index= st->nb_index_entries++;
1326 ie= &entries[index];
1327 assert(index==0 || ie[-1].timestamp < timestamp);
1329 ie= &entries[index];
1330 if(ie->timestamp != timestamp){
1331 if(ie->timestamp <= timestamp)
1333 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1334 st->nb_index_entries++;
1335 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1336 distance= ie->min_distance;
1340 ie->timestamp = timestamp;
1341 ie->min_distance= distance;
1348 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1351 AVIndexEntry *entries= st->index_entries;
1352 int nb_entries= st->nb_index_entries;
1359 //optimize appending index entries at the end
1360 if(b && entries[b-1].timestamp < wanted_timestamp)
1365 timestamp = entries[m].timestamp;
1366 if(timestamp >= wanted_timestamp)
1368 if(timestamp <= wanted_timestamp)
1371 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1373 if(!(flags & AVSEEK_FLAG_ANY)){
1374 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1375 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1386 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1387 AVInputFormat *avif= s->iformat;
1388 int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
1389 int64_t ts_min, ts_max, ts;
1394 if (stream_index < 0)
1398 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1402 ts_min= AV_NOPTS_VALUE;
1403 pos_limit= -1; //gcc falsely says it may be uninitialized
1405 st= s->streams[stream_index];
1406 if(st->index_entries){
1409 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()
1410 index= FFMAX(index, 0);
1411 e= &st->index_entries[index];
1413 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1415 ts_min= e->timestamp;
1417 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1424 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1425 assert(index < st->nb_index_entries);
1427 e= &st->index_entries[index];
1428 assert(e->timestamp >= target_ts);
1430 ts_max= e->timestamp;
1431 pos_limit= pos_max - e->min_distance;
1433 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1434 pos_max,pos_limit, ts_max);
1439 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1444 if ((ret = url_fseek(s->pb, pos, SEEK_SET)) < 0)
1447 av_update_cur_dts(s, st, ts);
1452 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 )){
1454 int64_t start_pos, filesize;
1458 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1461 if(ts_min == AV_NOPTS_VALUE){
1462 pos_min = s->data_offset;
1463 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1464 if (ts_min == AV_NOPTS_VALUE)
1468 if(ts_max == AV_NOPTS_VALUE){
1470 filesize = url_fsize(s->pb);
1471 pos_max = filesize - 1;
1474 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1476 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1477 if (ts_max == AV_NOPTS_VALUE)
1481 int64_t tmp_pos= pos_max + 1;
1482 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1483 if(tmp_ts == AV_NOPTS_VALUE)
1487 if(tmp_pos >= filesize)
1493 if(ts_min > ts_max){
1495 }else if(ts_min == ts_max){
1500 while (pos_min < pos_limit) {
1502 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1506 assert(pos_limit <= pos_max);
1509 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1510 // interpolate position (better than dichotomy)
1511 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1512 + pos_min - approximate_keyframe_distance;
1513 }else if(no_change==1){
1514 // bisection, if interpolation failed to change min or max pos last time
1515 pos = (pos_min + pos_limit)>>1;
1517 /* linear search if bisection failed, can only happen if there
1518 are very few or no keyframes between min/max */
1523 else if(pos > pos_limit)
1527 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1533 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n",
1534 pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit,
1535 start_pos, no_change);
1537 if(ts == AV_NOPTS_VALUE){
1538 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1541 assert(ts != AV_NOPTS_VALUE);
1542 if (target_ts <= ts) {
1543 pos_limit = start_pos - 1;
1547 if (target_ts >= ts) {
1553 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1554 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1557 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1559 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1560 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1561 pos, ts_min, target_ts, ts_max);
1567 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1568 int64_t pos_min, pos_max;
1572 if (stream_index < 0)
1575 st= s->streams[stream_index];
1578 pos_min = s->data_offset;
1579 pos_max = url_fsize(s->pb) - 1;
1581 if (pos < pos_min) pos= pos_min;
1582 else if(pos > pos_max) pos= pos_max;
1584 url_fseek(s->pb, pos, SEEK_SET);
1587 av_update_cur_dts(s, st, ts);
1592 static int av_seek_frame_generic(AVFormatContext *s,
1593 int stream_index, int64_t timestamp, int flags)
1600 st = s->streams[stream_index];
1602 index = av_index_search_timestamp(st, timestamp, flags);
1604 if(index < 0 && st->nb_index_entries && timestamp < st->index_entries[0].timestamp)
1607 if(index < 0 || index==st->nb_index_entries-1){
1611 if(st->nb_index_entries){
1612 assert(st->index_entries);
1613 ie= &st->index_entries[st->nb_index_entries-1];
1614 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1616 av_update_cur_dts(s, st, ie->timestamp);
1618 if ((ret = url_fseek(s->pb, s->data_offset, SEEK_SET)) < 0)
1624 ret = av_read_frame(s, &pkt);
1625 }while(ret == AVERROR(EAGAIN));
1628 av_free_packet(&pkt);
1629 if(stream_index == pkt.stream_index){
1630 if((pkt.flags & AV_PKT_FLAG_KEY) && pkt.dts > timestamp)
1634 index = av_index_search_timestamp(st, timestamp, flags);
1639 ff_read_frame_flush(s);
1640 if (s->iformat->read_seek){
1641 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1644 ie = &st->index_entries[index];
1645 if ((ret = url_fseek(s->pb, ie->pos, SEEK_SET)) < 0)
1647 av_update_cur_dts(s, st, ie->timestamp);
1652 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1657 ff_read_frame_flush(s);
1659 if(flags & AVSEEK_FLAG_BYTE)
1660 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1662 if(stream_index < 0){
1663 stream_index= av_find_default_stream_index(s);
1664 if(stream_index < 0)
1667 st= s->streams[stream_index];
1668 /* timestamp for default must be expressed in AV_TIME_BASE units */
1669 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1672 /* first, we try the format specific seek */
1673 if (s->iformat->read_seek)
1674 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1681 if(s->iformat->read_timestamp)
1682 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1684 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1687 int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
1689 if(min_ts > ts || max_ts < ts)
1692 ff_read_frame_flush(s);
1694 if (s->iformat->read_seek2)
1695 return s->iformat->read_seek2(s, stream_index, min_ts, ts, max_ts, flags);
1697 if(s->iformat->read_timestamp){
1698 //try to seek via read_timestamp()
1701 //Fallback to old API if new is not implemented but old is
1702 //Note the old has somewat different sematics
1703 if(s->iformat->read_seek || 1)
1704 return av_seek_frame(s, stream_index, ts, flags | (ts - min_ts > (uint64_t)(max_ts - ts) ? AVSEEK_FLAG_BACKWARD : 0));
1706 // try some generic seek like av_seek_frame_generic() but with new ts semantics
1709 /*******************************************************/
1712 * Returns TRUE if the stream has accurate duration in any stream.
1714 * @return TRUE if the stream has accurate duration for at least one component.
1716 static int av_has_duration(AVFormatContext *ic)
1721 for(i = 0;i < ic->nb_streams; i++) {
1722 st = ic->streams[i];
1723 if (st->duration != AV_NOPTS_VALUE)
1730 * Estimate the stream timings from the one of each components.
1732 * Also computes the global bitrate if possible.
1734 static void av_update_stream_timings(AVFormatContext *ic)
1736 int64_t start_time, start_time1, end_time, end_time1;
1737 int64_t duration, duration1;
1741 start_time = INT64_MAX;
1742 end_time = INT64_MIN;
1743 duration = INT64_MIN;
1744 for(i = 0;i < ic->nb_streams; i++) {
1745 st = ic->streams[i];
1746 if (st->start_time != AV_NOPTS_VALUE && st->time_base.den) {
1747 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1748 if (start_time1 < start_time)
1749 start_time = start_time1;
1750 if (st->duration != AV_NOPTS_VALUE) {
1751 end_time1 = start_time1
1752 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1753 if (end_time1 > end_time)
1754 end_time = end_time1;
1757 if (st->duration != AV_NOPTS_VALUE) {
1758 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1759 if (duration1 > duration)
1760 duration = duration1;
1763 if (start_time != INT64_MAX) {
1764 ic->start_time = start_time;
1765 if (end_time != INT64_MIN) {
1766 if (end_time - start_time > duration)
1767 duration = end_time - start_time;
1770 if (duration != INT64_MIN) {
1771 ic->duration = duration;
1772 if (ic->file_size > 0) {
1773 /* compute the bitrate */
1774 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1775 (double)ic->duration;
1780 static void fill_all_stream_timings(AVFormatContext *ic)
1785 av_update_stream_timings(ic);
1786 for(i = 0;i < ic->nb_streams; i++) {
1787 st = ic->streams[i];
1788 if (st->start_time == AV_NOPTS_VALUE) {
1789 if(ic->start_time != AV_NOPTS_VALUE)
1790 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1791 if(ic->duration != AV_NOPTS_VALUE)
1792 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1797 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1799 int64_t filesize, duration;
1803 /* if bit_rate is already set, we believe it */
1804 if (ic->bit_rate == 0) {
1806 for(i=0;i<ic->nb_streams;i++) {
1807 st = ic->streams[i];
1808 bit_rate += st->codec->bit_rate;
1810 ic->bit_rate = bit_rate;
1813 /* if duration is already set, we believe it */
1814 if (ic->duration == AV_NOPTS_VALUE &&
1815 ic->bit_rate != 0 &&
1816 ic->file_size != 0) {
1817 filesize = ic->file_size;
1819 for(i = 0; i < ic->nb_streams; i++) {
1820 st = ic->streams[i];
1821 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1822 if (st->duration == AV_NOPTS_VALUE)
1823 st->duration = duration;
1829 #define DURATION_MAX_READ_SIZE 250000
1830 #define DURATION_MAX_RETRY 3
1832 /* only usable for MPEG-PS streams */
1833 static void av_estimate_timings_from_pts(AVFormatContext *ic, int64_t old_offset)
1835 AVPacket pkt1, *pkt = &pkt1;
1837 int read_size, i, ret;
1838 int64_t end_time, start_time[MAX_STREAMS];
1839 int64_t filesize, offset, duration;
1844 /* flush packet queue */
1845 flush_packet_queue(ic);
1847 for(i=0;i<ic->nb_streams;i++) {
1848 st = ic->streams[i];
1849 if(st->start_time != AV_NOPTS_VALUE){
1850 start_time[i]= st->start_time;
1851 }else if(st->first_dts != AV_NOPTS_VALUE){
1852 start_time[i]= st->first_dts;
1854 av_log(st->codec, AV_LOG_WARNING, "start time is not set in av_estimate_timings_from_pts\n");
1857 av_parser_close(st->parser);
1859 av_free_packet(&st->cur_pkt);
1863 /* estimate the end time (duration) */
1864 /* XXX: may need to support wrapping */
1865 filesize = ic->file_size;
1866 end_time = AV_NOPTS_VALUE;
1868 offset = filesize - (DURATION_MAX_READ_SIZE<<retry);
1872 url_fseek(ic->pb, offset, SEEK_SET);
1875 if (read_size >= DURATION_MAX_READ_SIZE<<(FFMAX(retry-1,0)))
1879 ret = av_read_packet(ic, pkt);
1880 }while(ret == AVERROR(EAGAIN));
1883 read_size += pkt->size;
1884 st = ic->streams[pkt->stream_index];
1885 if (pkt->pts != AV_NOPTS_VALUE &&
1886 start_time[pkt->stream_index] != AV_NOPTS_VALUE) {
1887 end_time = pkt->pts;
1888 duration = end_time - start_time[pkt->stream_index];
1890 duration += 1LL<<st->pts_wrap_bits;
1892 if (st->duration == AV_NOPTS_VALUE ||
1893 st->duration < duration)
1894 st->duration = duration;
1897 av_free_packet(pkt);
1899 }while( end_time==AV_NOPTS_VALUE
1900 && filesize > (DURATION_MAX_READ_SIZE<<retry)
1901 && ++retry <= DURATION_MAX_RETRY);
1903 fill_all_stream_timings(ic);
1905 url_fseek(ic->pb, old_offset, SEEK_SET);
1906 for(i=0; i<ic->nb_streams; i++){
1908 st->cur_dts= st->first_dts;
1909 st->last_IP_pts = AV_NOPTS_VALUE;
1913 static void av_estimate_timings(AVFormatContext *ic, int64_t old_offset)
1917 /* get the file size, if possible */
1918 if (ic->iformat->flags & AVFMT_NOFILE) {
1921 file_size = url_fsize(ic->pb);
1925 ic->file_size = file_size;
1927 if ((!strcmp(ic->iformat->name, "mpeg") ||
1928 !strcmp(ic->iformat->name, "mpegts")) &&
1929 file_size && !url_is_streamed(ic->pb)) {
1930 /* get accurate estimate from the PTSes */
1931 av_estimate_timings_from_pts(ic, old_offset);
1932 } else if (av_has_duration(ic)) {
1933 /* at least one component has timings - we use them for all
1935 fill_all_stream_timings(ic);
1937 av_log(ic, AV_LOG_WARNING, "Estimating duration from bitrate, this may be inaccurate\n");
1938 /* less precise: use bitrate info */
1939 av_estimate_timings_from_bit_rate(ic);
1941 av_update_stream_timings(ic);
1947 for(i = 0;i < ic->nb_streams; i++) {
1948 st = ic->streams[i];
1949 printf("%d: start_time: %0.3f duration: %0.3f\n",
1950 i, (double)st->start_time / AV_TIME_BASE,
1951 (double)st->duration / AV_TIME_BASE);
1953 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1954 (double)ic->start_time / AV_TIME_BASE,
1955 (double)ic->duration / AV_TIME_BASE,
1956 ic->bit_rate / 1000);
1961 static int has_codec_parameters(AVCodecContext *enc)
1964 switch(enc->codec_type) {
1965 case AVMEDIA_TYPE_AUDIO:
1966 val = enc->sample_rate && enc->channels && enc->sample_fmt != SAMPLE_FMT_NONE;
1967 if(!enc->frame_size &&
1968 (enc->codec_id == CODEC_ID_VORBIS ||
1969 enc->codec_id == CODEC_ID_AAC ||
1970 enc->codec_id == CODEC_ID_MP1 ||
1971 enc->codec_id == CODEC_ID_MP2 ||
1972 enc->codec_id == CODEC_ID_MP3 ||
1973 enc->codec_id == CODEC_ID_SPEEX))
1976 case AVMEDIA_TYPE_VIDEO:
1977 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1983 return enc->codec_id != CODEC_ID_NONE && val != 0;
1986 static int try_decode_frame(AVStream *st, AVPacket *avpkt)
1990 int got_picture, data_size, ret=0;
1993 if(!st->codec->codec){
1994 codec = avcodec_find_decoder(st->codec->codec_id);
1997 ret = avcodec_open(st->codec, codec);
2002 if(!has_codec_parameters(st->codec)){
2003 switch(st->codec->codec_type) {
2004 case AVMEDIA_TYPE_VIDEO:
2005 avcodec_get_frame_defaults(&picture);
2006 ret = avcodec_decode_video2(st->codec, &picture,
2007 &got_picture, avpkt);
2009 case AVMEDIA_TYPE_AUDIO:
2010 data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
2011 samples = av_malloc(data_size);
2014 ret = avcodec_decode_audio3(st->codec, samples,
2026 unsigned int ff_codec_get_tag(const AVCodecTag *tags, int id)
2028 while (tags->id != CODEC_ID_NONE) {
2036 enum CodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
2039 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
2040 if(tag == tags[i].tag)
2043 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
2044 if( toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
2045 && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
2046 && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
2047 && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
2050 return CODEC_ID_NONE;
2053 unsigned int av_codec_get_tag(const AVCodecTag * const *tags, enum CodecID id)
2056 for(i=0; tags && tags[i]; i++){
2057 int tag= ff_codec_get_tag(tags[i], id);
2063 enum CodecID av_codec_get_id(const AVCodecTag * const *tags, unsigned int tag)
2066 for(i=0; tags && tags[i]; i++){
2067 enum CodecID id= ff_codec_get_id(tags[i], tag);
2068 if(id!=CODEC_ID_NONE) return id;
2070 return CODEC_ID_NONE;
2073 static void compute_chapters_end(AVFormatContext *s)
2077 for (i=0; i+1<s->nb_chapters; i++)
2078 if (s->chapters[i]->end == AV_NOPTS_VALUE) {
2079 assert(s->chapters[i]->start <= s->chapters[i+1]->start);
2080 assert(!av_cmp_q(s->chapters[i]->time_base, s->chapters[i+1]->time_base));
2081 s->chapters[i]->end = s->chapters[i+1]->start;
2084 if (s->nb_chapters && s->chapters[i]->end == AV_NOPTS_VALUE) {
2085 assert(s->start_time != AV_NOPTS_VALUE);
2086 assert(s->duration > 0);
2087 s->chapters[i]->end = av_rescale_q(s->start_time + s->duration,
2089 s->chapters[i]->time_base);
2093 #define MAX_STD_TIMEBASES (60*12+5)
2094 static int get_std_framerate(int i){
2095 if(i<60*12) return i*1001;
2096 else return ((const int[]){24,30,60,12,15})[i-60*12]*1000*12;
2100 * Is the time base unreliable.
2101 * This is a heuristic to balance between quick acceptance of the values in
2102 * the headers vs. some extra checks.
2103 * Old DivX and Xvid often have nonsense timebases like 1fps or 2fps.
2104 * MPEG-2 commonly misuses field repeat flags to store different framerates.
2105 * And there are "variable" fps files this needs to detect as well.
2107 static int tb_unreliable(AVCodecContext *c){
2108 if( c->time_base.den >= 101L*c->time_base.num
2109 || c->time_base.den < 5L*c->time_base.num
2110 /* || c->codec_tag == AV_RL32("DIVX")
2111 || c->codec_tag == AV_RL32("XVID")*/
2112 || c->codec_id == CODEC_ID_MPEG2VIDEO
2113 || c->codec_id == CODEC_ID_H264
2119 int av_find_stream_info(AVFormatContext *ic)
2121 int i, count, ret, read_size, j;
2123 AVPacket pkt1, *pkt;
2124 int64_t last_dts[MAX_STREAMS];
2125 int64_t duration_gcd[MAX_STREAMS]={0};
2126 int duration_count[MAX_STREAMS]={0};
2127 double (*duration_error)[MAX_STD_TIMEBASES];
2128 int64_t old_offset = url_ftell(ic->pb);
2129 int64_t codec_info_duration[MAX_STREAMS]={0};
2131 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
2132 if (!duration_error) return AVERROR(ENOMEM);
2134 for(i=0;i<ic->nb_streams;i++) {
2135 st = ic->streams[i];
2136 if (st->codec->codec_id == CODEC_ID_AAC) {
2137 st->codec->sample_rate = 0;
2138 st->codec->frame_size = 0;
2139 st->codec->channels = 0;
2141 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
2142 /* if(!st->time_base.num)
2144 if(!st->codec->time_base.num)
2145 st->codec->time_base= st->time_base;
2147 //only for the split stuff
2148 if (!st->parser && !(ic->flags & AVFMT_FLAG_NOPARSE)) {
2149 st->parser = av_parser_init(st->codec->codec_id);
2150 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
2151 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
2154 assert(!st->codec->codec);
2155 //try to just open decoders, in case this is enough to get parameters
2156 if(!has_codec_parameters(st->codec)){
2157 AVCodec *codec = avcodec_find_decoder(st->codec->codec_id);
2159 avcodec_open(st->codec, codec);
2163 for(i=0;i<MAX_STREAMS;i++){
2164 last_dts[i]= AV_NOPTS_VALUE;
2170 if(url_interrupt_cb()){
2171 ret= AVERROR(EINTR);
2172 av_log(ic, AV_LOG_DEBUG, "interrupted\n");
2176 /* check if one codec still needs to be handled */
2177 for(i=0;i<ic->nb_streams;i++) {
2178 st = ic->streams[i];
2179 if (!has_codec_parameters(st->codec))
2181 /* variable fps and no guess at the real fps */
2182 if( tb_unreliable(st->codec) && !(st->r_frame_rate.num && st->avg_frame_rate.num)
2183 && duration_count[i]<20 && st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2185 if(st->parser && st->parser->parser->split && !st->codec->extradata)
2187 if(st->first_dts == AV_NOPTS_VALUE)
2190 if (i == ic->nb_streams) {
2191 /* NOTE: if the format has no header, then we need to read
2192 some packets to get most of the streams, so we cannot
2194 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
2195 /* if we found the info for all the codecs, we can stop */
2197 av_log(ic, AV_LOG_DEBUG, "All info found\n");
2201 /* we did not get all the codec info, but we read too much data */
2202 if (read_size >= ic->probesize) {
2204 av_log(ic, AV_LOG_WARNING, "MAX_READ_SIZE:%d reached\n", ic->probesize);
2208 /* NOTE: a new stream can be added there if no header in file
2209 (AVFMTCTX_NOHEADER) */
2210 ret = av_read_frame_internal(ic, &pkt1);
2211 if(ret == AVERROR(EAGAIN))
2215 ret = -1; /* we could not have all the codec parameters before EOF */
2216 for(i=0;i<ic->nb_streams;i++) {
2217 st = ic->streams[i];
2218 if (!has_codec_parameters(st->codec)){
2220 avcodec_string(buf, sizeof(buf), st->codec, 0);
2221 av_log(ic, AV_LOG_WARNING, "Could not find codec parameters (%s)\n", buf);
2229 pkt= add_to_pktbuf(&ic->packet_buffer, &pkt1, &ic->packet_buffer_end);
2230 if(av_dup_packet(pkt) < 0) {
2231 av_free(duration_error);
2232 return AVERROR(ENOMEM);
2235 read_size += pkt->size;
2237 st = ic->streams[pkt->stream_index];
2238 if(st->codec_info_nb_frames>1) {
2239 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){
2240 av_log(ic, AV_LOG_WARNING, "max_analyze_duration reached\n");
2243 codec_info_duration[st->index] += pkt->duration;
2245 st->codec_info_nb_frames++;
2248 int index= pkt->stream_index;
2249 int64_t last= last_dts[index];
2250 int64_t duration= pkt->dts - last;
2252 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
2253 double dur= duration * av_q2d(st->time_base);
2255 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2256 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
2257 if(duration_count[index] < 2)
2258 memset(duration_error[index], 0, sizeof(*duration_error));
2259 for(i=1; i<MAX_STD_TIMEBASES; i++){
2260 int framerate= get_std_framerate(i);
2261 int ticks= lrintf(dur*framerate/(1001*12));
2262 double error= dur - ticks*1001*12/(double)framerate;
2263 duration_error[index][i] += error*error;
2265 duration_count[index]++;
2266 // ignore the first 4 values, they might have some random jitter
2267 if (duration_count[index] > 3)
2268 duration_gcd[index] = av_gcd(duration_gcd[index], duration);
2270 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
2271 last_dts[pkt->stream_index]= pkt->dts;
2273 if(st->parser && st->parser->parser->split && !st->codec->extradata){
2274 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
2276 st->codec->extradata_size= i;
2277 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
2278 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
2279 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
2283 /* if still no information, we try to open the codec and to
2284 decompress the frame. We try to avoid that in most cases as
2285 it takes longer and uses more memory. For MPEG-4, we need to
2286 decompress for QuickTime. */
2287 if (!has_codec_parameters(st->codec))
2288 try_decode_frame(st, pkt);
2293 // close codecs which were opened in try_decode_frame()
2294 for(i=0;i<ic->nb_streams;i++) {
2295 st = ic->streams[i];
2296 if(st->codec->codec)
2297 avcodec_close(st->codec);
2299 for(i=0;i<ic->nb_streams;i++) {
2300 st = ic->streams[i];
2301 if(st->codec_info_nb_frames>2 && !st->avg_frame_rate.num && codec_info_duration[i])
2302 av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
2303 (st->codec_info_nb_frames-2)*(int64_t)st->time_base.den,
2304 codec_info_duration[i] *(int64_t)st->time_base.num, 60000);
2305 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2306 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_coded_sample)
2307 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
2309 // the check for tb_unreliable() is not completely correct, since this is not about handling
2310 // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
2311 // ipmovie.c produces.
2312 if (tb_unreliable(st->codec) && duration_count[i] > 15 && duration_gcd[i] > 1 && !st->r_frame_rate.num)
2313 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);
2314 if(duration_count[i] && !st->r_frame_rate.num
2315 && tb_unreliable(st->codec) /*&&
2316 //FIXME we should not special-case MPEG-2, but this needs testing with non-MPEG-2 ...
2317 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
2319 double best_error= 2*av_q2d(st->time_base);
2320 best_error= best_error*best_error*duration_count[i]*1000*12*30;
2322 for(j=1; j<MAX_STD_TIMEBASES; j++){
2323 double error= duration_error[i][j] * get_std_framerate(j);
2324 // if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2325 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
2326 if(error < best_error){
2328 num = get_std_framerate(j);
2331 // do not increase frame rate by more than 1 % in order to match a standard rate.
2332 if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
2333 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
2336 if (!st->r_frame_rate.num){
2337 if( st->codec->time_base.den * (int64_t)st->time_base.num
2338 <= st->codec->time_base.num * st->codec->ticks_per_frame * (int64_t)st->time_base.den){
2339 st->r_frame_rate.num = st->codec->time_base.den;
2340 st->r_frame_rate.den = st->codec->time_base.num * st->codec->ticks_per_frame;
2342 st->r_frame_rate.num = st->time_base.den;
2343 st->r_frame_rate.den = st->time_base.num;
2346 }else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2347 if(!st->codec->bits_per_coded_sample)
2348 st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
2352 av_estimate_timings(ic, old_offset);
2354 compute_chapters_end(ic);
2357 /* correct DTS for B-frame streams with no timestamps */
2358 for(i=0;i<ic->nb_streams;i++) {
2359 st = ic->streams[i];
2360 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2362 ppktl = &ic->packet_buffer;
2364 if(ppkt1->stream_index != i)
2366 if(ppkt1->pkt->dts < 0)
2368 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2370 ppkt1->pkt->dts -= delta;
2375 st->cur_dts -= delta;
2381 av_free(duration_error);
2386 /*******************************************************/
2388 int av_read_play(AVFormatContext *s)
2390 if (s->iformat->read_play)
2391 return s->iformat->read_play(s);
2393 return av_url_read_fpause(s->pb, 0);
2394 return AVERROR(ENOSYS);
2397 int av_read_pause(AVFormatContext *s)
2399 if (s->iformat->read_pause)
2400 return s->iformat->read_pause(s);
2402 return av_url_read_fpause(s->pb, 1);
2403 return AVERROR(ENOSYS);
2406 void av_close_input_stream(AVFormatContext *s)
2411 if (s->iformat->read_close)
2412 s->iformat->read_close(s);
2413 for(i=0;i<s->nb_streams;i++) {
2414 /* free all data in a stream component */
2417 av_parser_close(st->parser);
2418 av_free_packet(&st->cur_pkt);
2420 av_metadata_free(&st->metadata);
2421 av_free(st->index_entries);
2422 av_free(st->codec->extradata);
2424 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2425 av_free(st->filename);
2427 av_free(st->priv_data);
2430 for(i=s->nb_programs-1; i>=0; i--) {
2431 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2432 av_freep(&s->programs[i]->provider_name);
2433 av_freep(&s->programs[i]->name);
2435 av_metadata_free(&s->programs[i]->metadata);
2436 av_freep(&s->programs[i]->stream_index);
2437 av_freep(&s->programs[i]);
2439 av_freep(&s->programs);
2440 flush_packet_queue(s);
2441 av_freep(&s->priv_data);
2442 while(s->nb_chapters--) {
2443 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2444 av_free(s->chapters[s->nb_chapters]->title);
2446 av_metadata_free(&s->chapters[s->nb_chapters]->metadata);
2447 av_free(s->chapters[s->nb_chapters]);
2449 av_freep(&s->chapters);
2450 av_metadata_free(&s->metadata);
2454 void av_close_input_file(AVFormatContext *s)
2456 ByteIOContext *pb = s->iformat->flags & AVFMT_NOFILE ? NULL : s->pb;
2457 av_close_input_stream(s);
2462 AVStream *av_new_stream(AVFormatContext *s, int id)
2467 if (s->nb_streams >= MAX_STREAMS)
2470 st = av_mallocz(sizeof(AVStream));
2474 st->codec= avcodec_alloc_context();
2476 /* no default bitrate if decoding */
2477 st->codec->bit_rate = 0;
2479 st->index = s->nb_streams;
2481 st->start_time = AV_NOPTS_VALUE;
2482 st->duration = AV_NOPTS_VALUE;
2483 /* we set the current DTS to 0 so that formats without any timestamps
2484 but durations get some timestamps, formats with some unknown
2485 timestamps have their first few packets buffered and the
2486 timestamps corrected before they are returned to the user */
2488 st->first_dts = AV_NOPTS_VALUE;
2489 st->probe_packets = MAX_PROBE_PACKETS;
2491 /* default pts setting is MPEG-like */
2492 av_set_pts_info(st, 33, 1, 90000);
2493 st->last_IP_pts = AV_NOPTS_VALUE;
2494 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2495 st->pts_buffer[i]= AV_NOPTS_VALUE;
2496 st->reference_dts = AV_NOPTS_VALUE;
2498 st->sample_aspect_ratio = (AVRational){0,1};
2500 s->streams[s->nb_streams++] = st;
2504 AVProgram *av_new_program(AVFormatContext *ac, int id)
2506 AVProgram *program=NULL;
2510 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2513 for(i=0; i<ac->nb_programs; i++)
2514 if(ac->programs[i]->id == id)
2515 program = ac->programs[i];
2518 program = av_mallocz(sizeof(AVProgram));
2521 dynarray_add(&ac->programs, &ac->nb_programs, program);
2522 program->discard = AVDISCARD_NONE;
2529 AVChapter *ff_new_chapter(AVFormatContext *s, int id, AVRational time_base, int64_t start, int64_t end, const char *title)
2531 AVChapter *chapter = NULL;
2534 for(i=0; i<s->nb_chapters; i++)
2535 if(s->chapters[i]->id == id)
2536 chapter = s->chapters[i];
2539 chapter= av_mallocz(sizeof(AVChapter));
2542 dynarray_add(&s->chapters, &s->nb_chapters, chapter);
2544 #if LIBAVFORMAT_VERSION_INT < (53<<16)
2545 av_free(chapter->title);
2547 av_metadata_set(&chapter->metadata, "title", title);
2549 chapter->time_base= time_base;
2550 chapter->start = start;
2556 /************************************************************/
2557 /* output media file */
2559 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2563 if (s->oformat->priv_data_size > 0) {
2564 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2566 return AVERROR(ENOMEM);
2568 s->priv_data = NULL;
2570 if (s->oformat->set_parameters) {
2571 ret = s->oformat->set_parameters(s, ap);
2578 int av_write_header(AVFormatContext *s)
2583 // some sanity checks
2584 if (s->nb_streams == 0) {
2585 av_log(s, AV_LOG_ERROR, "no streams\n");
2589 for(i=0;i<s->nb_streams;i++) {
2592 switch (st->codec->codec_type) {
2593 case AVMEDIA_TYPE_AUDIO:
2594 if(st->codec->sample_rate<=0){
2595 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2598 if(!st->codec->block_align)
2599 st->codec->block_align = st->codec->channels *
2600 av_get_bits_per_sample(st->codec->codec_id) >> 3;
2602 case AVMEDIA_TYPE_VIDEO:
2603 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2604 av_log(s, AV_LOG_ERROR, "time base not set\n");
2607 if((st->codec->width<=0 || st->codec->height<=0) && !(s->oformat->flags & AVFMT_NODIMENSIONS)){
2608 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2611 if(av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)){
2612 av_log(s, AV_LOG_ERROR, "Aspect ratio mismatch between encoder and muxer layer\n");
2618 if(s->oformat->codec_tag){
2619 if(st->codec->codec_tag){
2621 //check that tag + id is in the table
2622 //if neither is in the table -> OK
2623 //if tag is in the table with another id -> FAIL
2624 //if id is in the table with another tag -> FAIL unless strict < ?
2626 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2629 if(s->oformat->flags & AVFMT_GLOBALHEADER &&
2630 !(st->codec->flags & CODEC_FLAG_GLOBAL_HEADER))
2631 av_log(s, AV_LOG_WARNING, "Codec for stream %d does not use global headers but container format requires global headers\n", i);
2634 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2635 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2637 return AVERROR(ENOMEM);
2640 #if LIBAVFORMAT_VERSION_MAJOR < 53
2641 ff_metadata_mux_compat(s);
2644 /* set muxer identification string */
2645 if (!(s->streams[0]->codec->flags & CODEC_FLAG_BITEXACT)) {
2649 if (!(m = av_mallocz(sizeof(AVMetadata))))
2650 return AVERROR(ENOMEM);
2651 av_metadata_set2(&m, "encoder", LIBAVFORMAT_IDENT, 0);
2652 metadata_conv(&m, s->oformat->metadata_conv, NULL);
2653 if ((t = av_metadata_get(m, "", NULL, AV_METADATA_IGNORE_SUFFIX)))
2654 av_metadata_set2(&s->metadata, t->key, t->value, 0);
2655 av_metadata_free(&m);
2658 if(s->oformat->write_header){
2659 ret = s->oformat->write_header(s);
2664 /* init PTS generation */
2665 for(i=0;i<s->nb_streams;i++) {
2666 int64_t den = AV_NOPTS_VALUE;
2669 switch (st->codec->codec_type) {
2670 case AVMEDIA_TYPE_AUDIO:
2671 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2673 case AVMEDIA_TYPE_VIDEO:
2674 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2679 if (den != AV_NOPTS_VALUE) {
2681 return AVERROR_INVALIDDATA;
2682 av_frac_init(&st->pts, 0, 0, den);
2688 //FIXME merge with compute_pkt_fields
2689 static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){
2690 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2691 int num, den, frame_size, i;
2693 // 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);
2695 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2698 /* duration field */
2699 if (pkt->duration == 0) {
2700 compute_frame_duration(&num, &den, st, NULL, pkt);
2702 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den * st->codec->ticks_per_frame, den * (int64_t)st->time_base.num);
2706 if(pkt->pts == AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && delay==0)
2709 //XXX/FIXME this is a temporary hack until all encoders output pts
2710 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2712 // pkt->pts= st->cur_dts;
2713 pkt->pts= st->pts.val;
2716 //calculate dts from pts
2717 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE && delay <= MAX_REORDER_DELAY){
2718 st->pts_buffer[0]= pkt->pts;
2719 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2720 st->pts_buffer[i]= pkt->pts + (i-delay-1) * pkt->duration;
2721 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2722 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2724 pkt->dts= st->pts_buffer[0];
2727 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2728 av_log(s, AV_LOG_ERROR,
2729 "st:%d error, non monotone timestamps %"PRId64" >= %"PRId64"\n",
2730 st->index, st->cur_dts, pkt->dts);
2733 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2734 av_log(s, AV_LOG_ERROR, "st:%d error, pts < dts\n", st->index);
2738 // av_log(s, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2739 st->cur_dts= pkt->dts;
2740 st->pts.val= pkt->dts;
2743 switch (st->codec->codec_type) {
2744 case AVMEDIA_TYPE_AUDIO:
2745 frame_size = get_audio_frame_size(st->codec, pkt->size);
2747 /* HACK/FIXME, we skip the initial 0 size packets as they are most
2748 likely equal to the encoder delay, but it would be better if we
2749 had the real timestamps from the encoder */
2750 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2751 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2754 case AVMEDIA_TYPE_VIDEO:
2755 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2763 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2765 int ret = compute_pkt_fields2(s, s->streams[pkt->stream_index], pkt);
2767 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2770 ret= s->oformat->write_packet(s, pkt);
2772 ret= url_ferror(s->pb);
2776 void ff_interleave_add_packet(AVFormatContext *s, AVPacket *pkt,
2777 int (*compare)(AVFormatContext *, AVPacket *, AVPacket *))
2779 AVPacketList **next_point, *this_pktl;
2781 this_pktl = av_mallocz(sizeof(AVPacketList));
2782 this_pktl->pkt= *pkt;
2783 pkt->destruct= NULL; // do not free original but only the copy
2784 av_dup_packet(&this_pktl->pkt); // duplicate the packet if it uses non-alloced memory
2786 if(s->streams[pkt->stream_index]->last_in_packet_buffer){
2787 next_point = &(s->streams[pkt->stream_index]->last_in_packet_buffer->next);
2789 next_point = &s->packet_buffer;
2792 if(compare(s, &s->packet_buffer_end->pkt, pkt)){
2793 while(!compare(s, &(*next_point)->pkt, pkt)){
2794 next_point= &(*next_point)->next;
2798 next_point = &(s->packet_buffer_end->next);
2801 assert(!*next_point);
2803 s->packet_buffer_end= this_pktl;
2806 this_pktl->next= *next_point;
2808 s->streams[pkt->stream_index]->last_in_packet_buffer=
2809 *next_point= this_pktl;
2812 int ff_interleave_compare_dts(AVFormatContext *s, AVPacket *next, AVPacket *pkt)
2814 AVStream *st = s->streams[ pkt ->stream_index];
2815 AVStream *st2= s->streams[ next->stream_index];
2816 int64_t a= st2->time_base.num * (int64_t)st ->time_base.den;
2817 int64_t b= st ->time_base.num * (int64_t)st2->time_base.den;
2818 return av_rescale_rnd(pkt->dts, b, a, AV_ROUND_DOWN) < next->dts;
2821 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2827 ff_interleave_add_packet(s, pkt, ff_interleave_compare_dts);
2830 for(i=0; i < s->nb_streams; i++)
2831 stream_count+= !!s->streams[i]->last_in_packet_buffer;
2833 if(stream_count && (s->nb_streams == stream_count || flush)){
2834 pktl= s->packet_buffer;
2837 s->packet_buffer= pktl->next;
2838 if(!s->packet_buffer)
2839 s->packet_buffer_end= NULL;
2841 if(s->streams[out->stream_index]->last_in_packet_buffer == pktl)
2842 s->streams[out->stream_index]->last_in_packet_buffer= NULL;
2846 av_init_packet(out);
2852 * Interleaves an AVPacket correctly so it can be muxed.
2853 * @param out the interleaved packet will be output here
2854 * @param in the input packet
2855 * @param flush 1 if no further packets are available as input and all
2856 * remaining packets should be output
2857 * @return 1 if a packet was output, 0 if no packet could be output,
2858 * < 0 if an error occurred
2860 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2861 if(s->oformat->interleave_packet)
2862 return s->oformat->interleave_packet(s, out, in, flush);
2864 return av_interleave_packet_per_dts(s, out, in, flush);
2867 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2868 AVStream *st= s->streams[ pkt->stream_index];
2870 //FIXME/XXX/HACK drop zero sized packets
2871 if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO && pkt->size==0)
2874 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2875 if(compute_pkt_fields2(s, st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2878 if(pkt->dts == AV_NOPTS_VALUE && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2883 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2884 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2887 ret= s->oformat->write_packet(s, &opkt);
2889 av_free_packet(&opkt);
2894 if(url_ferror(s->pb))
2895 return url_ferror(s->pb);
2899 int av_write_trailer(AVFormatContext *s)
2905 ret= av_interleave_packet(s, &pkt, NULL, 1);
2906 if(ret<0) //FIXME cleanup needed for ret<0 ?
2911 ret= s->oformat->write_packet(s, &pkt);
2913 av_free_packet(&pkt);
2917 if(url_ferror(s->pb))
2921 if(s->oformat->write_trailer)
2922 ret = s->oformat->write_trailer(s);
2925 ret=url_ferror(s->pb);
2926 for(i=0;i<s->nb_streams;i++) {
2927 av_freep(&s->streams[i]->priv_data);
2928 av_freep(&s->streams[i]->index_entries);
2930 av_freep(&s->priv_data);
2934 void ff_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2937 AVProgram *program=NULL;
2940 if (idx >= ac->nb_streams) {
2941 av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
2945 for(i=0; i<ac->nb_programs; i++){
2946 if(ac->programs[i]->id != progid)
2948 program = ac->programs[i];
2949 for(j=0; j<program->nb_stream_indexes; j++)
2950 if(program->stream_index[j] == idx)
2953 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2956 program->stream_index = tmp;
2957 program->stream_index[program->nb_stream_indexes++] = idx;
2962 static void print_fps(double d, const char *postfix){
2963 uint64_t v= lrintf(d*100);
2964 if (v% 100 ) av_log(NULL, AV_LOG_INFO, ", %3.2f %s", d, postfix);
2965 else if(v%(100*1000)) av_log(NULL, AV_LOG_INFO, ", %1.0f %s", d, postfix);
2966 else av_log(NULL, AV_LOG_INFO, ", %1.0fk %s", d/1000, postfix);
2969 static void dump_metadata(void *ctx, AVMetadata *m, const char *indent)
2971 if(m && !(m->count == 1 && av_metadata_get(m, "language", NULL, 0))){
2972 AVMetadataTag *tag=NULL;
2974 av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
2975 while((tag=av_metadata_get(m, "", tag, AV_METADATA_IGNORE_SUFFIX))) {
2976 if(strcmp("language", tag->key))
2977 av_log(ctx, AV_LOG_INFO, "%s %-16s: %s\n", indent, tag->key, tag->value);
2982 /* "user interface" functions */
2983 static void dump_stream_format(AVFormatContext *ic, int i, int index, int is_output)
2986 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2987 AVStream *st = ic->streams[i];
2988 int g = av_gcd(st->time_base.num, st->time_base.den);
2989 AVMetadataTag *lang = av_metadata_get(st->metadata, "language", NULL, 0);
2990 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2991 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2992 /* the pid is an important information, so we display it */
2993 /* XXX: add a generic system */
2994 if (flags & AVFMT_SHOW_IDS)
2995 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2997 av_log(NULL, AV_LOG_INFO, "(%s)", lang->value);
2998 av_log(NULL, AV_LOG_DEBUG, ", %d, %d/%d", st->codec_info_nb_frames, st->time_base.num/g, st->time_base.den/g);
2999 av_log(NULL, AV_LOG_INFO, ": %s", buf);
3000 if (st->sample_aspect_ratio.num && // default
3001 av_cmp_q(st->sample_aspect_ratio, st->codec->sample_aspect_ratio)) {
3002 AVRational display_aspect_ratio;
3003 av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
3004 st->codec->width*st->sample_aspect_ratio.num,
3005 st->codec->height*st->sample_aspect_ratio.den,
3007 av_log(NULL, AV_LOG_INFO, ", PAR %d:%d DAR %d:%d",
3008 st->sample_aspect_ratio.num, st->sample_aspect_ratio.den,
3009 display_aspect_ratio.num, display_aspect_ratio.den);
3011 if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
3012 if(st->avg_frame_rate.den && st->avg_frame_rate.num)
3013 print_fps(av_q2d(st->avg_frame_rate), "fps");
3014 if(st->r_frame_rate.den && st->r_frame_rate.num)
3015 print_fps(av_q2d(st->r_frame_rate), "tbr");
3016 if(st->time_base.den && st->time_base.num)
3017 print_fps(1/av_q2d(st->time_base), "tbn");
3018 if(st->codec->time_base.den && st->codec->time_base.num)
3019 print_fps(1/av_q2d(st->codec->time_base), "tbc");
3021 av_log(NULL, AV_LOG_INFO, "\n");
3022 dump_metadata(NULL, st->metadata, " ");
3025 void dump_format(AVFormatContext *ic,
3031 uint8_t *printed = av_mallocz(ic->nb_streams);
3032 if (ic->nb_streams && !printed)
3035 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
3036 is_output ? "Output" : "Input",
3038 is_output ? ic->oformat->name : ic->iformat->name,
3039 is_output ? "to" : "from", url);
3040 dump_metadata(NULL, ic->metadata, " ");
3042 av_log(NULL, AV_LOG_INFO, " Duration: ");
3043 if (ic->duration != AV_NOPTS_VALUE) {
3044 int hours, mins, secs, us;
3045 secs = ic->duration / AV_TIME_BASE;
3046 us = ic->duration % AV_TIME_BASE;
3051 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%02d", hours, mins, secs,
3052 (100 * us) / AV_TIME_BASE);
3054 av_log(NULL, AV_LOG_INFO, "N/A");
3056 if (ic->start_time != AV_NOPTS_VALUE) {
3058 av_log(NULL, AV_LOG_INFO, ", start: ");
3059 secs = ic->start_time / AV_TIME_BASE;
3060 us = ic->start_time % AV_TIME_BASE;
3061 av_log(NULL, AV_LOG_INFO, "%d.%06d",
3062 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
3064 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
3066 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
3068 av_log(NULL, AV_LOG_INFO, "N/A");
3070 av_log(NULL, AV_LOG_INFO, "\n");
3072 for (i = 0; i < ic->nb_chapters; i++) {
3073 AVChapter *ch = ic->chapters[i];
3074 av_log(NULL, AV_LOG_INFO, " Chapter #%d.%d: ", index, i);
3075 av_log(NULL, AV_LOG_INFO, "start %f, ", ch->start * av_q2d(ch->time_base));
3076 av_log(NULL, AV_LOG_INFO, "end %f\n", ch->end * av_q2d(ch->time_base));
3078 dump_metadata(NULL, ch->metadata, " ");
3080 if(ic->nb_programs) {
3081 int j, k, total = 0;
3082 for(j=0; j<ic->nb_programs; j++) {
3083 AVMetadataTag *name = av_metadata_get(ic->programs[j]->metadata,
3085 av_log(NULL, AV_LOG_INFO, " Program %d %s\n", ic->programs[j]->id,
3086 name ? name->value : "");
3087 dump_metadata(NULL, ic->programs[j]->metadata, " ");
3088 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++) {
3089 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, is_output);
3090 printed[ic->programs[j]->stream_index[k]] = 1;
3092 total += ic->programs[j]->nb_stream_indexes;
3094 if (total < ic->nb_streams)
3095 av_log(NULL, AV_LOG_INFO, " No Program\n");
3097 for(i=0;i<ic->nb_streams;i++)
3099 dump_stream_format(ic, i, index, is_output);
3104 #if LIBAVFORMAT_VERSION_MAJOR < 53
3105 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
3107 return av_parse_video_frame_size(width_ptr, height_ptr, str);
3110 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
3112 AVRational frame_rate;
3113 int ret = av_parse_video_frame_rate(&frame_rate, arg);
3114 *frame_rate_num= frame_rate.num;
3115 *frame_rate_den= frame_rate.den;
3120 int64_t av_gettime(void)
3123 gettimeofday(&tv,NULL);
3124 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
3127 uint64_t ff_ntp_time(void)
3129 return (av_gettime() / 1000) * 1000 + NTP_OFFSET_US;
3132 int64_t parse_date(const char *datestr, int duration)
3138 static const char * const date_fmt[] = {
3142 static const char * const time_fmt[] = {
3152 time_t now = time(0);
3154 len = strlen(datestr);
3156 lastch = datestr[len - 1];
3159 is_utc = (lastch == 'z' || lastch == 'Z');
3161 memset(&dt, 0, sizeof(dt));
3166 if (!strncasecmp(datestr, "now", len))
3167 return (int64_t) now * 1000000;
3169 /* parse the year-month-day part */
3170 for (i = 0; i < FF_ARRAY_ELEMS(date_fmt); i++) {
3171 q = small_strptime(p, date_fmt[i], &dt);
3177 /* if the year-month-day part is missing, then take the
3178 * current year-month-day time */
3183 dt = *localtime(&now);
3185 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
3190 if (*p == 'T' || *p == 't' || *p == ' ')
3193 /* parse the hour-minute-second part */
3194 for (i = 0; i < FF_ARRAY_ELEMS(time_fmt); i++) {
3195 q = small_strptime(p, time_fmt[i], &dt);
3201 /* parse datestr as a duration */
3206 /* parse datestr as HH:MM:SS */
3207 q = small_strptime(p, time_fmt[0], &dt);
3209 /* parse datestr as S+ */
3210 dt.tm_sec = strtol(p, (char **)&q, 10);
3212 /* the parsing didn't succeed */
3219 /* Now we have all the fields that we can get */
3225 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
3227 dt.tm_isdst = -1; /* unknown */
3237 /* parse the .m... part */
3241 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
3244 val += n * (*q - '0');
3248 return negative ? -t : t;
3251 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
3261 while (*p != '\0' && *p != '=' && *p != '&') {
3262 if ((q - tag) < sizeof(tag) - 1)
3270 while (*p != '&' && *p != '\0') {
3271 if ((q - arg) < arg_size - 1) {
3281 if (!strcmp(tag, tag1))
3290 int av_get_frame_filename(char *buf, int buf_size,
3291 const char *path, int number)
3294 char *q, buf1[20], c;
3295 int nd, len, percentd_found;
3307 while (isdigit(*p)) {
3308 nd = nd * 10 + *p++ - '0';
3311 } while (isdigit(c));
3320 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
3322 if ((q - buf + len) > buf_size - 1)
3324 memcpy(q, buf1, len);
3332 if ((q - buf) < buf_size - 1)
3336 if (!percentd_found)
3345 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
3349 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3351 for(i=0;i<size;i+=16) {
3358 PRINT(" %02x", buf[i+j]);
3363 for(j=0;j<len;j++) {
3365 if (c < ' ' || c > '~')
3374 void av_hex_dump(FILE *f, uint8_t *buf, int size)
3376 hex_dump_internal(NULL, f, 0, buf, size);
3379 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
3381 hex_dump_internal(avcl, NULL, level, buf, size);
3384 //FIXME needs to know the time_base
3385 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
3388 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
3389 PRINT("stream #%d:\n", pkt->stream_index);
3390 PRINT(" keyframe=%d\n", ((pkt->flags & AV_PKT_FLAG_KEY) != 0));
3391 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
3392 /* DTS is _always_ valid after av_read_frame() */
3394 if (pkt->dts == AV_NOPTS_VALUE)
3397 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
3398 /* PTS may not be known if B-frames are present. */
3400 if (pkt->pts == AV_NOPTS_VALUE)
3403 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
3405 PRINT(" size=%d\n", pkt->size);
3408 av_hex_dump(f, pkt->data, pkt->size);
3411 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
3413 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
3416 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
3418 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
3421 void ff_url_split(char *proto, int proto_size,
3422 char *authorization, int authorization_size,
3423 char *hostname, int hostname_size,
3425 char *path, int path_size,
3428 const char *p, *ls, *at, *col, *brk;
3430 if (port_ptr) *port_ptr = -1;
3431 if (proto_size > 0) proto[0] = 0;
3432 if (authorization_size > 0) authorization[0] = 0;
3433 if (hostname_size > 0) hostname[0] = 0;
3434 if (path_size > 0) path[0] = 0;
3436 /* parse protocol */
3437 if ((p = strchr(url, ':'))) {
3438 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
3443 /* no protocol means plain filename */
3444 av_strlcpy(path, url, path_size);
3448 /* separate path from hostname */
3449 ls = strchr(p, '/');
3451 ls = strchr(p, '?');
3453 av_strlcpy(path, ls, path_size);
3455 ls = &p[strlen(p)]; // XXX
3457 /* the rest is hostname, use that to parse auth/port */
3459 /* authorization (user[:pass]@hostname) */
3460 if ((at = strchr(p, '@')) && at < ls) {
3461 av_strlcpy(authorization, p,
3462 FFMIN(authorization_size, at + 1 - p));
3463 p = at + 1; /* skip '@' */
3466 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
3468 av_strlcpy(hostname, p + 1,
3469 FFMIN(hostname_size, brk - p));
3470 if (brk[1] == ':' && port_ptr)
3471 *port_ptr = atoi(brk + 2);
3472 } else if ((col = strchr(p, ':')) && col < ls) {
3473 av_strlcpy(hostname, p,
3474 FFMIN(col + 1 - p, hostname_size));
3475 if (port_ptr) *port_ptr = atoi(col + 1);
3477 av_strlcpy(hostname, p,
3478 FFMIN(ls + 1 - p, hostname_size));
3482 char *ff_data_to_hex(char *buff, const uint8_t *src, int s, int lowercase)
3485 static const char hex_table_uc[16] = { '0', '1', '2', '3',
3488 'C', 'D', 'E', 'F' };
3489 static const char hex_table_lc[16] = { '0', '1', '2', '3',
3492 'c', 'd', 'e', 'f' };
3493 const char *hex_table = lowercase ? hex_table_lc : hex_table_uc;
3495 for(i = 0; i < s; i++) {
3496 buff[i * 2] = hex_table[src[i] >> 4];
3497 buff[i * 2 + 1] = hex_table[src[i] & 0xF];
3503 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
3504 unsigned int pts_num, unsigned int pts_den)
3506 s->pts_wrap_bits = pts_wrap_bits;
3508 if(av_reduce(&s->time_base.num, &s->time_base.den, pts_num, pts_den, INT_MAX)){
3509 if(s->time_base.num != pts_num)
3510 av_log(NULL, AV_LOG_DEBUG, "st:%d removing common factor %d from timebase\n", s->index, pts_num/s->time_base.num);
3512 av_log(NULL, AV_LOG_WARNING, "st:%d has too large timebase, reducing\n", s->index);
3514 if(!s->time_base.num || !s->time_base.den)
3515 s->time_base.num= s->time_base.den= 0;
3518 int ff_url_join(char *str, int size, const char *proto,
3519 const char *authorization, const char *hostname,
3520 int port, const char *fmt, ...)
3523 struct addrinfo hints, *ai;
3528 av_strlcatf(str, size, "%s://", proto);
3530 av_strlcatf(str, size, "%s@", authorization);
3531 #if CONFIG_NETWORK && defined(AF_INET6)
3532 /* Determine if hostname is a numerical IPv6 address,
3533 * properly escape it within [] in that case. */
3534 memset(&hints, 0, sizeof(hints));
3535 hints.ai_flags = AI_NUMERICHOST;
3536 if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
3537 if (ai->ai_family == AF_INET6) {
3538 av_strlcat(str, "[", size);
3539 av_strlcat(str, hostname, size);
3540 av_strlcat(str, "]", size);
3542 av_strlcat(str, hostname, size);
3547 /* Not an IPv6 address, just output the plain string. */
3548 av_strlcat(str, hostname, size);
3551 av_strlcatf(str, size, ":%d", port);
3554 int len = strlen(str);
3557 vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);