2 * Various utilities for ffmpeg system
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
22 #include "allformats.h"
33 * @file libavformat/utils.c
34 * Various utility functions for using ffmpeg library.
37 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
38 static void av_frac_add(AVFrac *f, int64_t incr);
40 /** head of registered input format linked list. */
41 AVInputFormat *first_iformat = NULL;
42 /** head of registered output format linked list. */
43 AVOutputFormat *first_oformat = NULL;
45 void av_register_input_format(AVInputFormat *format)
49 while (*p != NULL) p = &(*p)->next;
54 void av_register_output_format(AVOutputFormat *format)
58 while (*p != NULL) p = &(*p)->next;
63 int match_ext(const char *filename, const char *extensions)
71 ext = strrchr(filename, '.');
77 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
80 if (!strcasecmp(ext1, ext))
90 AVOutputFormat *guess_format(const char *short_name, const char *filename,
91 const char *mime_type)
93 AVOutputFormat *fmt, *fmt_found;
96 /* specific test for image sequences */
97 #ifdef CONFIG_IMAGE2_MUXER
98 if (!short_name && filename &&
99 av_filename_number_test(filename) &&
100 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
101 return guess_format("image2", NULL, NULL);
104 /* find the proper file type */
108 while (fmt != NULL) {
110 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
112 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
114 if (filename && fmt->extensions &&
115 match_ext(filename, fmt->extensions)) {
118 if (score > score_max) {
127 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
128 const char *mime_type)
130 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
133 AVOutputFormat *stream_fmt;
134 char stream_format_name[64];
136 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
137 stream_fmt = guess_format(stream_format_name, NULL, NULL);
146 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
147 const char *filename, const char *mime_type, enum CodecType type){
148 if(type == CODEC_TYPE_VIDEO){
149 enum CodecID codec_id= CODEC_ID_NONE;
151 #ifdef CONFIG_IMAGE2_MUXER
152 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
153 codec_id= av_guess_image2_codec(filename);
156 if(codec_id == CODEC_ID_NONE)
157 codec_id= fmt->video_codec;
159 }else if(type == CODEC_TYPE_AUDIO)
160 return fmt->audio_codec;
162 return CODEC_ID_NONE;
165 AVInputFormat *av_find_input_format(const char *short_name)
168 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
169 if (!strcmp(fmt->name, short_name))
175 /* memory handling */
177 void av_destruct_packet(AVPacket *pkt)
180 pkt->data = NULL; pkt->size = 0;
183 void av_init_packet(AVPacket *pkt)
185 pkt->pts = AV_NOPTS_VALUE;
186 pkt->dts = AV_NOPTS_VALUE;
190 pkt->stream_index = 0;
191 pkt->destruct= av_destruct_packet_nofree;
194 int av_new_packet(AVPacket *pkt, int size)
197 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
198 return AVERROR(ENOMEM);
199 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
201 return AVERROR(ENOMEM);
202 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
207 pkt->destruct = av_destruct_packet;
211 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
213 int ret= av_new_packet(pkt, size);
218 pkt->pos= url_ftell(s);
220 ret= get_buffer(s, pkt->data, size);
229 int av_dup_packet(AVPacket *pkt)
231 if (pkt->destruct != av_destruct_packet) {
233 /* we duplicate the packet and don't forget to put the padding
235 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
236 return AVERROR(ENOMEM);
237 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
239 return AVERROR(ENOMEM);
241 memcpy(data, pkt->data, pkt->size);
242 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
244 pkt->destruct = av_destruct_packet;
249 int av_filename_number_test(const char *filename)
252 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
255 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
257 AVInputFormat *fmt1, *fmt;
261 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
262 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
265 if (fmt1->read_probe) {
266 score = fmt1->read_probe(pd);
267 } else if (fmt1->extensions) {
268 if (match_ext(pd->filename, fmt1->extensions)) {
272 if (score > *score_max) {
280 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
282 return av_probe_input_format2(pd, is_opened, &score);
285 /************************************************************/
286 /* input media file */
289 * Open a media file from an IO stream. 'fmt' must be specified.
291 static const char* format_to_name(void* ptr)
293 AVFormatContext* fc = (AVFormatContext*) ptr;
294 if(fc->iformat) return fc->iformat->name;
295 else if(fc->oformat) return fc->oformat->name;
299 #define OFFSET(x) offsetof(AVFormatContext,x)
300 #define DEFAULT 0 //should be NAN but it does not work as it is not a constant in glibc as required by ANSI/ISO C
301 //these names are too long to be readable
302 #define E AV_OPT_FLAG_ENCODING_PARAM
303 #define D AV_OPT_FLAG_DECODING_PARAM
305 static const AVOption options[]={
306 {"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
307 {"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
308 {"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
309 {"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
310 {"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
311 {"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
312 {"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
313 {"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
314 {"analyzeduration", "how many microseconds are analyzed to estimate duration", OFFSET(max_analyze_duration), FF_OPT_TYPE_INT, 3*AV_TIME_BASE, 0, INT_MAX, D},
322 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
324 static void avformat_get_context_defaults(AVFormatContext *s)
326 memset(s, 0, sizeof(AVFormatContext));
328 s->av_class = &av_format_context_class;
330 av_opt_set_defaults(s);
333 AVFormatContext *av_alloc_format_context(void)
336 ic = av_malloc(sizeof(AVFormatContext));
338 avformat_get_context_defaults(ic);
339 ic->av_class = &av_format_context_class;
343 int av_open_input_stream(AVFormatContext **ic_ptr,
344 ByteIOContext *pb, const char *filename,
345 AVInputFormat *fmt, AVFormatParameters *ap)
349 AVFormatParameters default_ap;
353 memset(ap, 0, sizeof(default_ap));
356 if(!ap->prealloced_context)
357 ic = av_alloc_format_context();
361 err = AVERROR(ENOMEM);
367 ic->duration = AV_NOPTS_VALUE;
368 ic->start_time = AV_NOPTS_VALUE;
369 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
371 /* allocate private data */
372 if (fmt->priv_data_size > 0) {
373 ic->priv_data = av_mallocz(fmt->priv_data_size);
374 if (!ic->priv_data) {
375 err = AVERROR(ENOMEM);
379 ic->priv_data = NULL;
382 err = ic->iformat->read_header(ic, ap);
386 if (pb && !ic->data_offset)
387 ic->data_offset = url_ftell(&ic->pb);
393 av_freep(&ic->priv_data);
400 /** Size of probe buffer, for guessing file type from file contents. */
401 #define PROBE_BUF_MIN 2048
402 #define PROBE_BUF_MAX (1<<20)
404 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
407 AVFormatParameters *ap)
409 int err, must_open_file, file_opened, probe_size;
410 AVProbeData probe_data, *pd = &probe_data;
411 ByteIOContext pb1, *pb = &pb1;
416 pd->filename = filename;
421 /* guess format if no file can be opened */
422 fmt = av_probe_input_format(pd, 0);
425 /* do not open file if the format does not need it. XXX: specific
426 hack needed to handle RTSP/TCP */
428 if (fmt && (fmt->flags & AVFMT_NOFILE)) {
430 pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise it is uninitialized
433 if (!fmt || must_open_file) {
434 /* if no file needed do not try to open one */
435 if ((err=url_fopen(pb, filename, URL_RDONLY)) < 0) {
440 url_setbufsize(pb, buf_size);
443 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
444 int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
445 /* read probe data */
446 pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
447 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
448 if (url_fseek(pb, 0, SEEK_SET) < 0) {
450 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
456 /* guess file format */
457 fmt = av_probe_input_format2(pd, 1, &score);
462 /* if still no format found, error */
468 /* XXX: suppress this hack for redirectors */
469 #ifdef CONFIG_REDIR_DEMUXER
470 if (fmt == &redir_demuxer) {
471 err = redir_open(ic_ptr, pb);
477 /* check filename in case of an image number is expected */
478 if (fmt->flags & AVFMT_NEEDNUMBER) {
479 if (!av_filename_number_test(filename)) {
480 err = AVERROR_NUMEXPECTED;
484 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
497 /*******************************************************/
499 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
502 return s->iformat->read_packet(s, pkt);
505 /**********************************************************/
508 * Get the number of samples of an audio frame. Return (-1) if error.
510 static int get_audio_frame_size(AVCodecContext *enc, int size)
514 if (enc->frame_size <= 1) {
515 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
517 if (bits_per_sample) {
518 if (enc->channels == 0)
520 frame_size = (size << 3) / (bits_per_sample * enc->channels);
522 /* used for example by ADPCM codecs */
523 if (enc->bit_rate == 0)
525 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
528 frame_size = enc->frame_size;
535 * Return the frame duration in seconds, return 0 if not available.
537 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
538 AVCodecParserContext *pc, AVPacket *pkt)
544 switch(st->codec->codec_type) {
545 case CODEC_TYPE_VIDEO:
546 if(st->time_base.num*1000LL > st->time_base.den){
547 *pnum = st->time_base.num;
548 *pden = st->time_base.den;
549 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
550 *pnum = st->codec->time_base.num;
551 *pden = st->codec->time_base.den;
552 if (pc && pc->repeat_pict) {
554 *pnum = (*pnum) * (2 + pc->repeat_pict);
558 case CODEC_TYPE_AUDIO:
559 frame_size = get_audio_frame_size(st->codec, pkt->size);
563 *pden = st->codec->sample_rate;
570 static int is_intra_only(AVCodecContext *enc){
571 if(enc->codec_type == CODEC_TYPE_AUDIO){
573 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
574 switch(enc->codec_id){
576 case CODEC_ID_MJPEGB:
578 case CODEC_ID_RAWVIDEO:
579 case CODEC_ID_DVVIDEO:
580 case CODEC_ID_HUFFYUV:
581 case CODEC_ID_FFVHUFF:
592 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
593 AVCodecParserContext *pc, AVPacket *pkt)
595 int num, den, presentation_delayed, delay, i;
598 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
599 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
600 pkt->dts -= 1LL<<st->pts_wrap_bits;
603 if (pkt->duration == 0) {
604 compute_frame_duration(&num, &den, st, pc, pkt);
606 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
610 /* correct timestamps with byte offset if demuxers only have timestamps on packet boundaries */
611 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
612 /* this will estimate bitrate based on this frame's duration and size */
613 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
614 if(pkt->pts != AV_NOPTS_VALUE)
616 if(pkt->dts != AV_NOPTS_VALUE)
620 if(is_intra_only(st->codec))
621 pkt->flags |= PKT_FLAG_KEY;
623 /* do we have a video B frame ? */
624 delay= st->codec->has_b_frames;
625 presentation_delayed = 0;
626 /* XXX: need has_b_frame, but cannot get it if the codec is
629 pc && pc->pict_type != FF_B_TYPE)
630 presentation_delayed = 1;
631 /* This may be redundant, but it should not hurt. */
632 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
633 presentation_delayed = 1;
635 if(st->cur_dts == AV_NOPTS_VALUE){
636 st->cur_dts = -delay * pkt->duration;
639 // 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);
640 /* interpolate PTS and DTS if they are not present */
642 if (presentation_delayed) {
643 /* DTS = decompression time stamp */
644 /* PTS = presentation time stamp */
645 if (pkt->dts == AV_NOPTS_VALUE)
646 pkt->dts = st->last_IP_pts;
647 if (pkt->dts == AV_NOPTS_VALUE)
648 pkt->dts = st->cur_dts;
650 /* this is tricky: the dts must be incremented by the duration
651 of the frame we are displaying, i.e. the last I or P frame */
652 if (st->last_IP_duration == 0)
653 st->last_IP_duration = pkt->duration;
654 st->cur_dts = pkt->dts + st->last_IP_duration;
655 st->last_IP_duration = pkt->duration;
656 st->last_IP_pts= pkt->pts;
657 /* cannot compute PTS if not present (we can compute it only
658 by knowing the futur */
659 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
660 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
661 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
662 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
663 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
664 pkt->pts += pkt->duration;
665 // 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);
669 /* presentation is not delayed : PTS and DTS are the same */
670 if(pkt->pts == AV_NOPTS_VALUE)
672 if(pkt->pts == AV_NOPTS_VALUE)
673 pkt->pts = st->cur_dts;
675 st->cur_dts = pkt->pts + pkt->duration;
679 if(pkt->pts != AV_NOPTS_VALUE){
680 st->pts_buffer[0]= pkt->pts;
681 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
682 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
683 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
684 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
685 if(pkt->dts == AV_NOPTS_VALUE)
686 pkt->dts= st->pts_buffer[0];
687 if(pkt->dts > st->cur_dts)
688 st->cur_dts = pkt->dts;
691 // 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);
696 /* key frame computation */
697 if (pc->pict_type == FF_I_TYPE)
698 pkt->flags |= PKT_FLAG_KEY;
702 void av_destruct_packet_nofree(AVPacket *pkt)
704 pkt->data = NULL; pkt->size = 0;
707 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
715 /* select current input stream component */
718 if (!st->need_parsing || !st->parser) {
719 /* no parsing needed: we just output the packet as is */
720 /* raw data support */
722 compute_pkt_fields(s, st, NULL, pkt);
725 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
726 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
727 s->cur_ptr, s->cur_len,
728 s->cur_pkt.pts, s->cur_pkt.dts);
729 s->cur_pkt.pts = AV_NOPTS_VALUE;
730 s->cur_pkt.dts = AV_NOPTS_VALUE;
731 /* increment read pointer */
735 /* return packet if any */
738 pkt->pos = s->cur_pkt.pos; // Isn't quite accurate but close.
740 pkt->stream_index = st->index;
741 pkt->pts = st->parser->pts;
742 pkt->dts = st->parser->dts;
743 pkt->destruct = av_destruct_packet_nofree;
744 compute_pkt_fields(s, st, st->parser, pkt);
746 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
747 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
748 0, 0, AVINDEX_KEYFRAME);
755 av_free_packet(&s->cur_pkt);
759 /* read next packet */
760 ret = av_read_packet(s, &s->cur_pkt);
762 if (ret == AVERROR(EAGAIN))
764 /* return the last frames, if any */
765 for(i = 0; i < s->nb_streams; i++) {
767 if (st->parser && st->need_parsing) {
768 av_parser_parse(st->parser, st->codec,
769 &pkt->data, &pkt->size,
771 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
776 /* no more packets: really terminates parsing */
780 st = s->streams[s->cur_pkt.stream_index];
781 if(st->codec->debug & FF_DEBUG_PTS)
782 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
783 s->cur_pkt.stream_index,
789 s->cur_ptr = s->cur_pkt.data;
790 s->cur_len = s->cur_pkt.size;
791 if (st->need_parsing && !st->parser) {
792 st->parser = av_parser_init(st->codec->codec_id);
794 /* no parser available : just output the raw packets */
795 st->need_parsing = AVSTREAM_PARSE_NONE;
796 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
797 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
799 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
800 st->parser->last_frame_offset=
801 st->parser->cur_offset= s->cur_pkt.pos;
806 if(st->codec->debug & FF_DEBUG_PTS)
807 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
816 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
820 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
823 pktl = s->packet_buffer;
825 AVPacket *next_pkt= &pktl->pkt;
827 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
828 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
829 if( pktl->pkt.stream_index == next_pkt->stream_index
830 && next_pkt->dts < pktl->pkt.dts
831 && pktl->pkt.pts != pktl->pkt.dts //not b frame
832 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
833 next_pkt->pts= pktl->pkt.dts;
837 pktl = s->packet_buffer;
840 if( next_pkt->pts != AV_NOPTS_VALUE
841 || next_pkt->dts == AV_NOPTS_VALUE
843 /* read packet from packet buffer, if there is data */
845 s->packet_buffer = pktl->next;
851 AVPacketList **plast_pktl= &s->packet_buffer;
852 int ret= av_read_frame_internal(s, pkt);
854 if(pktl && ret != AVERROR(EAGAIN)){
861 /* duplicate the packet */
862 if (av_dup_packet(pkt) < 0)
863 return AVERROR(ENOMEM);
865 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
867 pktl = av_mallocz(sizeof(AVPacketList));
869 return AVERROR(ENOMEM);
871 /* add the packet in the buffered packet list */
875 assert(!s->packet_buffer);
876 return av_read_frame_internal(s, pkt);
881 /* XXX: suppress the packet queue */
882 static void flush_packet_queue(AVFormatContext *s)
887 pktl = s->packet_buffer;
890 s->packet_buffer = pktl->next;
891 av_free_packet(&pktl->pkt);
896 /*******************************************************/
899 int av_find_default_stream_index(AVFormatContext *s)
904 if (s->nb_streams <= 0)
906 for(i = 0; i < s->nb_streams; i++) {
908 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
916 * Flush the frame reader.
918 static void av_read_frame_flush(AVFormatContext *s)
923 flush_packet_queue(s);
925 /* free previous packet */
927 if (s->cur_st->parser)
928 av_free_packet(&s->cur_pkt);
935 /* for each stream, reset read state */
936 for(i = 0; i < s->nb_streams; i++) {
940 av_parser_close(st->parser);
943 st->last_IP_pts = AV_NOPTS_VALUE;
944 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
948 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
951 for(i = 0; i < s->nb_streams; i++) {
952 AVStream *st = s->streams[i];
954 st->cur_dts = av_rescale(timestamp,
955 st->time_base.den * (int64_t)ref_st->time_base.num,
956 st->time_base.num * (int64_t)ref_st->time_base.den);
960 int av_add_index_entry(AVStream *st,
961 int64_t pos, int64_t timestamp, int size, int distance, int flags)
963 AVIndexEntry *entries, *ie;
966 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
969 entries = av_fast_realloc(st->index_entries,
970 &st->index_entries_allocated_size,
971 (st->nb_index_entries + 1) *
972 sizeof(AVIndexEntry));
976 st->index_entries= entries;
978 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
981 index= st->nb_index_entries++;
983 assert(index==0 || ie[-1].timestamp < timestamp);
986 if(ie->timestamp != timestamp){
987 if(ie->timestamp <= timestamp)
989 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
990 st->nb_index_entries++;
991 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
992 distance= ie->min_distance;
996 ie->timestamp = timestamp;
997 ie->min_distance= distance;
1004 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1007 AVIndexEntry *entries= st->index_entries;
1008 int nb_entries= st->nb_index_entries;
1017 timestamp = entries[m].timestamp;
1018 if(timestamp >= wanted_timestamp)
1020 if(timestamp <= wanted_timestamp)
1023 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1025 if(!(flags & AVSEEK_FLAG_ANY)){
1026 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1027 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1038 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1039 AVInputFormat *avif= s->iformat;
1040 int64_t pos_min, pos_max, pos, pos_limit;
1041 int64_t ts_min, ts_max, ts;
1045 if (stream_index < 0)
1049 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1053 ts_min= AV_NOPTS_VALUE;
1054 pos_limit= -1; //gcc falsely says it may be uninitialized
1056 st= s->streams[stream_index];
1057 if(st->index_entries){
1060 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()
1061 index= FFMAX(index, 0);
1062 e= &st->index_entries[index];
1064 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1066 ts_min= e->timestamp;
1068 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1075 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1076 assert(index < st->nb_index_entries);
1078 e= &st->index_entries[index];
1079 assert(e->timestamp >= target_ts);
1081 ts_max= e->timestamp;
1082 pos_limit= pos_max - e->min_distance;
1084 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1085 pos_max,pos_limit, ts_max);
1090 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1095 url_fseek(&s->pb, pos, SEEK_SET);
1097 av_update_cur_dts(s, st, ts);
1102 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 )){
1104 int64_t start_pos, filesize;
1108 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1111 if(ts_min == AV_NOPTS_VALUE){
1112 pos_min = s->data_offset;
1113 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1114 if (ts_min == AV_NOPTS_VALUE)
1118 if(ts_max == AV_NOPTS_VALUE){
1120 filesize = url_fsize(&s->pb);
1121 pos_max = filesize - 1;
1124 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1126 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1127 if (ts_max == AV_NOPTS_VALUE)
1131 int64_t tmp_pos= pos_max + 1;
1132 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1133 if(tmp_ts == AV_NOPTS_VALUE)
1137 if(tmp_pos >= filesize)
1143 if(ts_min > ts_max){
1145 }else if(ts_min == ts_max){
1150 while (pos_min < pos_limit) {
1152 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1156 assert(pos_limit <= pos_max);
1159 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1160 // interpolate position (better than dichotomy)
1161 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1162 + pos_min - approximate_keyframe_distance;
1163 }else if(no_change==1){
1164 // bisection, if interpolation failed to change min or max pos last time
1165 pos = (pos_min + pos_limit)>>1;
1167 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1172 else if(pos > pos_limit)
1176 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1182 av_log(s, AV_LOG_DEBUG, "%"PRId64" %"PRId64" %"PRId64" / %"PRId64" %"PRId64" %"PRId64" target:%"PRId64" limit:%"PRId64" start:%"PRId64" noc:%d\n", pos_min, pos, pos_max, ts_min, ts, ts_max, target_ts, pos_limit, start_pos, no_change);
1184 if(ts == AV_NOPTS_VALUE){
1185 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1188 assert(ts != AV_NOPTS_VALUE);
1189 if (target_ts <= ts) {
1190 pos_limit = start_pos - 1;
1194 if (target_ts >= ts) {
1200 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1201 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1204 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1206 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1207 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1208 pos, ts_min, target_ts, ts_max);
1214 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1215 int64_t pos_min, pos_max;
1219 if (stream_index < 0)
1222 st= s->streams[stream_index];
1225 pos_min = s->data_offset;
1226 pos_max = url_fsize(&s->pb) - 1;
1228 if (pos < pos_min) pos= pos_min;
1229 else if(pos > pos_max) pos= pos_max;
1231 url_fseek(&s->pb, pos, SEEK_SET);
1234 av_update_cur_dts(s, st, ts);
1239 static int av_seek_frame_generic(AVFormatContext *s,
1240 int stream_index, int64_t timestamp, int flags)
1246 st = s->streams[stream_index];
1248 index = av_index_search_timestamp(st, timestamp, flags);
1250 if(index < 0 || index==st->nb_index_entries-1){
1254 if(st->index_entries && st->nb_index_entries){
1255 ie= &st->index_entries[st->nb_index_entries-1];
1256 url_fseek(&s->pb, ie->pos, SEEK_SET);
1257 av_update_cur_dts(s, st, ie->timestamp);
1259 url_fseek(&s->pb, 0, SEEK_SET);
1262 int ret = av_read_frame(s, &pkt);
1265 av_free_packet(&pkt);
1266 if(stream_index == pkt.stream_index){
1267 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1271 index = av_index_search_timestamp(st, timestamp, flags);
1276 av_read_frame_flush(s);
1277 if (s->iformat->read_seek){
1278 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1281 ie = &st->index_entries[index];
1282 url_fseek(&s->pb, ie->pos, SEEK_SET);
1284 av_update_cur_dts(s, st, ie->timestamp);
1289 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1294 av_read_frame_flush(s);
1296 if(flags & AVSEEK_FLAG_BYTE)
1297 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1299 if(stream_index < 0){
1300 stream_index= av_find_default_stream_index(s);
1301 if(stream_index < 0)
1304 st= s->streams[stream_index];
1305 /* timestamp for default must be expressed in AV_TIME_BASE units */
1306 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1308 st= s->streams[stream_index];
1310 /* first, we try the format specific seek */
1311 if (s->iformat->read_seek)
1312 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1319 if(s->iformat->read_timestamp)
1320 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1322 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1325 /*******************************************************/
1328 * Returns TRUE if the stream has accurate timings in any stream.
1330 * @return TRUE if the stream has accurate timings for at least one component.
1332 static int av_has_timings(AVFormatContext *ic)
1337 for(i = 0;i < ic->nb_streams; i++) {
1338 st = ic->streams[i];
1339 if (st->start_time != AV_NOPTS_VALUE &&
1340 st->duration != AV_NOPTS_VALUE)
1347 * Estimate the stream timings from the one of each components.
1349 * Also computes the global bitrate if possible.
1351 static void av_update_stream_timings(AVFormatContext *ic)
1353 int64_t start_time, start_time1, end_time, end_time1;
1357 start_time = INT64_MAX;
1358 end_time = INT64_MIN;
1359 for(i = 0;i < ic->nb_streams; i++) {
1360 st = ic->streams[i];
1361 if (st->start_time != AV_NOPTS_VALUE) {
1362 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1363 if (start_time1 < start_time)
1364 start_time = start_time1;
1365 if (st->duration != AV_NOPTS_VALUE) {
1366 end_time1 = start_time1
1367 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1368 if (end_time1 > end_time)
1369 end_time = end_time1;
1373 if (start_time != INT64_MAX) {
1374 ic->start_time = start_time;
1375 if (end_time != INT64_MIN) {
1376 ic->duration = end_time - start_time;
1377 if (ic->file_size > 0) {
1378 /* compute the bit rate */
1379 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1380 (double)ic->duration;
1387 static void fill_all_stream_timings(AVFormatContext *ic)
1392 av_update_stream_timings(ic);
1393 for(i = 0;i < ic->nb_streams; i++) {
1394 st = ic->streams[i];
1395 if (st->start_time == AV_NOPTS_VALUE) {
1396 if(ic->start_time != AV_NOPTS_VALUE)
1397 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1398 if(ic->duration != AV_NOPTS_VALUE)
1399 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1404 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1406 int64_t filesize, duration;
1410 /* if bit_rate is already set, we believe it */
1411 if (ic->bit_rate == 0) {
1413 for(i=0;i<ic->nb_streams;i++) {
1414 st = ic->streams[i];
1415 bit_rate += st->codec->bit_rate;
1417 ic->bit_rate = bit_rate;
1420 /* if duration is already set, we believe it */
1421 if (ic->duration == AV_NOPTS_VALUE &&
1422 ic->bit_rate != 0 &&
1423 ic->file_size != 0) {
1424 filesize = ic->file_size;
1426 for(i = 0; i < ic->nb_streams; i++) {
1427 st = ic->streams[i];
1428 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1429 if (st->start_time == AV_NOPTS_VALUE ||
1430 st->duration == AV_NOPTS_VALUE) {
1432 st->duration = duration;
1439 #define DURATION_MAX_READ_SIZE 250000
1441 /* only usable for MPEG-PS streams */
1442 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1444 AVPacket pkt1, *pkt = &pkt1;
1446 int read_size, i, ret;
1448 int64_t filesize, offset, duration;
1450 /* free previous packet */
1451 if (ic->cur_st && ic->cur_st->parser)
1452 av_free_packet(&ic->cur_pkt);
1455 /* flush packet queue */
1456 flush_packet_queue(ic);
1458 for(i=0;i<ic->nb_streams;i++) {
1459 st = ic->streams[i];
1461 av_parser_close(st->parser);
1466 /* we read the first packets to get the first PTS (not fully
1467 accurate, but it is enough now) */
1468 url_fseek(&ic->pb, 0, SEEK_SET);
1471 if (read_size >= DURATION_MAX_READ_SIZE)
1473 /* if all info is available, we can stop */
1474 for(i = 0;i < ic->nb_streams; i++) {
1475 st = ic->streams[i];
1476 if (st->start_time == AV_NOPTS_VALUE)
1479 if (i == ic->nb_streams)
1482 ret = av_read_packet(ic, pkt);
1485 read_size += pkt->size;
1486 st = ic->streams[pkt->stream_index];
1487 if (pkt->pts != AV_NOPTS_VALUE) {
1488 if (st->start_time == AV_NOPTS_VALUE)
1489 st->start_time = pkt->pts;
1491 av_free_packet(pkt);
1494 /* estimate the end time (duration) */
1495 /* XXX: may need to support wrapping */
1496 filesize = ic->file_size;
1497 offset = filesize - DURATION_MAX_READ_SIZE;
1501 url_fseek(&ic->pb, offset, SEEK_SET);
1504 if (read_size >= DURATION_MAX_READ_SIZE)
1506 /* if all info is available, we can stop */
1507 for(i = 0;i < ic->nb_streams; i++) {
1508 st = ic->streams[i];
1509 if (st->duration == AV_NOPTS_VALUE)
1512 if (i == ic->nb_streams)
1515 ret = av_read_packet(ic, pkt);
1518 read_size += pkt->size;
1519 st = ic->streams[pkt->stream_index];
1520 if (pkt->pts != AV_NOPTS_VALUE) {
1521 end_time = pkt->pts;
1522 duration = end_time - st->start_time;
1524 if (st->duration == AV_NOPTS_VALUE ||
1525 st->duration < duration)
1526 st->duration = duration;
1529 av_free_packet(pkt);
1532 fill_all_stream_timings(ic);
1534 url_fseek(&ic->pb, old_offset, SEEK_SET);
1537 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1541 /* get the file size, if possible */
1542 if (ic->iformat->flags & AVFMT_NOFILE) {
1545 file_size = url_fsize(&ic->pb);
1549 ic->file_size = file_size;
1551 if ((!strcmp(ic->iformat->name, "mpeg") ||
1552 !strcmp(ic->iformat->name, "mpegts")) &&
1553 file_size && !ic->pb.is_streamed) {
1554 /* get accurate estimate from the PTSes */
1555 av_estimate_timings_from_pts(ic, old_offset);
1556 } else if (av_has_timings(ic)) {
1557 /* at least one components has timings - we use them for all
1559 fill_all_stream_timings(ic);
1561 /* less precise: use bit rate info */
1562 av_estimate_timings_from_bit_rate(ic);
1564 av_update_stream_timings(ic);
1570 for(i = 0;i < ic->nb_streams; i++) {
1571 st = ic->streams[i];
1572 printf("%d: start_time: %0.3f duration: %0.3f\n",
1573 i, (double)st->start_time / AV_TIME_BASE,
1574 (double)st->duration / AV_TIME_BASE);
1576 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1577 (double)ic->start_time / AV_TIME_BASE,
1578 (double)ic->duration / AV_TIME_BASE,
1579 ic->bit_rate / 1000);
1584 static int has_codec_parameters(AVCodecContext *enc)
1587 switch(enc->codec_type) {
1588 case CODEC_TYPE_AUDIO:
1589 val = enc->sample_rate;
1591 case CODEC_TYPE_VIDEO:
1592 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1601 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1605 int got_picture, data_size, ret=0;
1608 if(!st->codec->codec){
1609 codec = avcodec_find_decoder(st->codec->codec_id);
1612 ret = avcodec_open(st->codec, codec);
1617 if(!has_codec_parameters(st->codec)){
1618 switch(st->codec->codec_type) {
1619 case CODEC_TYPE_VIDEO:
1620 ret = avcodec_decode_video(st->codec, &picture,
1621 &got_picture, (uint8_t *)data, size);
1623 case CODEC_TYPE_AUDIO:
1624 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1625 samples = av_malloc(data_size);
1628 ret = avcodec_decode_audio2(st->codec, samples,
1629 &data_size, (uint8_t *)data, size);
1640 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1643 fmt = av_probe_input_format2(pd, 1, &score);
1646 if (strncmp(fmt->name, "mp3", 3) == 0)
1647 st->codec->codec_id = CODEC_ID_MP3;
1648 else if (strncmp(fmt->name, "ac3", 3) == 0)
1649 st->codec->codec_id = CODEC_ID_AC3;
1654 unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1656 while (tags->id != CODEC_ID_NONE) {
1664 enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1667 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1668 if(tag == tags[i].tag)
1671 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1672 if( toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1673 && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1674 && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1675 && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1678 return CODEC_ID_NONE;
1681 unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1684 for(i=0; tags && tags[i]; i++){
1685 int tag= codec_get_tag(tags[i], id);
1691 enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1694 for(i=0; tags && tags[i]; i++){
1695 enum CodecID id= codec_get_id(tags[i], tag);
1696 if(id!=CODEC_ID_NONE) return id;
1698 return CODEC_ID_NONE;
1701 /* absolute maximum size we read until we abort */
1702 #define MAX_READ_SIZE 5000000
1704 #define MAX_STD_TIMEBASES (60*12+5)
1705 static int get_std_framerate(int i){
1706 if(i<60*12) return i*1001;
1707 else return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1710 int av_find_stream_info(AVFormatContext *ic)
1712 int i, count, ret, read_size, j;
1714 AVPacket pkt1, *pkt;
1715 AVPacketList *pktl=NULL, **ppktl;
1716 int64_t last_dts[MAX_STREAMS];
1717 int duration_count[MAX_STREAMS]={0};
1718 double (*duration_error)[MAX_STD_TIMEBASES];
1719 offset_t old_offset = url_ftell(&ic->pb);
1720 int64_t codec_info_duration[MAX_STREAMS]={0};
1721 int codec_info_nb_frames[MAX_STREAMS]={0};
1722 AVProbeData probe_data[MAX_STREAMS];
1723 int codec_identified[MAX_STREAMS]={0};
1725 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1726 if (!duration_error) return AVERROR(ENOMEM);
1728 for(i=0;i<ic->nb_streams;i++) {
1729 st = ic->streams[i];
1730 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1731 /* if(!st->time_base.num)
1733 if(!st->codec->time_base.num)
1734 st->codec->time_base= st->time_base;
1736 //only for the split stuff
1738 st->parser = av_parser_init(st->codec->codec_id);
1739 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1740 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1745 for(i=0;i<MAX_STREAMS;i++){
1746 last_dts[i]= AV_NOPTS_VALUE;
1749 memset(probe_data, 0, sizeof(probe_data));
1752 ppktl = &ic->packet_buffer;
1754 /* check if one codec still needs to be handled */
1755 for(i=0;i<ic->nb_streams;i++) {
1756 st = ic->streams[i];
1757 if (!has_codec_parameters(st->codec))
1759 /* variable fps and no guess at the real fps */
1760 if( (st->codec->time_base.den >= 101LL*st->codec->time_base.num || st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
1761 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1763 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1765 if (st->codec->codec_type == CODEC_TYPE_AUDIO &&
1766 st->codec->codec_id == CODEC_ID_NONE)
1769 if (i == ic->nb_streams) {
1770 /* NOTE: if the format has no header, then we need to read
1771 some packets to get most of the streams, so we cannot
1773 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1774 /* if we found the info for all the codecs, we can stop */
1779 /* we did not get all the codec info, but we read too much data */
1780 if (read_size >= MAX_READ_SIZE) {
1785 /* NOTE: a new stream can be added there if no header in file
1786 (AVFMTCTX_NOHEADER) */
1787 ret = av_read_frame_internal(ic, &pkt1);
1790 ret = -1; /* we could not have all the codec parameters before EOF */
1791 for(i=0;i<ic->nb_streams;i++) {
1792 st = ic->streams[i];
1793 if (!has_codec_parameters(st->codec)){
1795 avcodec_string(buf, sizeof(buf), st->codec, 0);
1796 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1804 pktl = av_mallocz(sizeof(AVPacketList));
1806 ret = AVERROR(ENOMEM);
1810 /* add the packet in the buffered packet list */
1812 ppktl = &pktl->next;
1817 /* duplicate the packet */
1818 if (av_dup_packet(pkt) < 0) {
1819 ret = AVERROR(ENOMEM);
1823 read_size += pkt->size;
1825 st = ic->streams[pkt->stream_index];
1826 if(codec_info_nb_frames[st->index]>1)
1827 codec_info_duration[st->index] += pkt->duration;
1828 if (pkt->duration != 0)
1829 codec_info_nb_frames[st->index]++;
1832 int index= pkt->stream_index;
1833 int64_t last= last_dts[index];
1834 int64_t duration= pkt->dts - last;
1836 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1837 double dur= duration * av_q2d(st->time_base);
1839 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1840 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1841 if(duration_count[index] < 2)
1842 memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1843 for(i=1; i<MAX_STD_TIMEBASES; i++){
1844 int framerate= get_std_framerate(i);
1845 int ticks= lrintf(dur*framerate/(1001*12));
1846 double error= dur - ticks*1001*12/(double)framerate;
1847 duration_error[index][i] += error*error;
1849 duration_count[index]++;
1851 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1852 last_dts[pkt->stream_index]= pkt->dts;
1854 if (st->codec->codec_id == CODEC_ID_NONE) {
1855 AVProbeData *pd = &(probe_data[st->index]);
1856 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size);
1857 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1858 pd->buf_size += pkt->size;
1861 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1862 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1864 st->codec->extradata_size= i;
1865 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1866 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1867 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1871 /* if still no information, we try to open the codec and to
1872 decompress the frame. We try to avoid that in most cases as
1873 it takes longer and uses more memory. For MPEG4, we need to
1874 decompress for Quicktime. */
1875 if (!has_codec_parameters(st->codec) /*&&
1876 (st->codec->codec_id == CODEC_ID_FLV1 ||
1877 st->codec->codec_id == CODEC_ID_H264 ||
1878 st->codec->codec_id == CODEC_ID_H263 ||
1879 st->codec->codec_id == CODEC_ID_H261 ||
1880 st->codec->codec_id == CODEC_ID_VORBIS ||
1881 st->codec->codec_id == CODEC_ID_MJPEG ||
1882 st->codec->codec_id == CODEC_ID_PNG ||
1883 st->codec->codec_id == CODEC_ID_PAM ||
1884 st->codec->codec_id == CODEC_ID_PGM ||
1885 st->codec->codec_id == CODEC_ID_PGMYUV ||
1886 st->codec->codec_id == CODEC_ID_PBM ||
1887 st->codec->codec_id == CODEC_ID_PPM ||
1888 st->codec->codec_id == CODEC_ID_SHORTEN ||
1889 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1890 try_decode_frame(st, pkt->data, pkt->size);
1892 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) {
1898 // close codecs which where opened in try_decode_frame()
1899 for(i=0;i<ic->nb_streams;i++) {
1900 st = ic->streams[i];
1901 if(st->codec->codec)
1902 avcodec_close(st->codec);
1904 for(i=0;i<ic->nb_streams;i++) {
1905 st = ic->streams[i];
1906 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1907 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1908 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1910 if(duration_count[i]
1911 && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1912 //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1913 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1914 double best_error= 2*av_q2d(st->time_base);
1915 best_error= best_error*best_error*duration_count[i]*1000*12*30;
1917 for(j=1; j<MAX_STD_TIMEBASES; j++){
1918 double error= duration_error[i][j] * get_std_framerate(j);
1919 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1920 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1921 if(error < best_error){
1923 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1928 if (!st->r_frame_rate.num){
1929 if( st->codec->time_base.den * (int64_t)st->time_base.num
1930 <= st->codec->time_base.num * (int64_t)st->time_base.den){
1931 st->r_frame_rate.num = st->codec->time_base.den;
1932 st->r_frame_rate.den = st->codec->time_base.num;
1934 st->r_frame_rate.num = st->time_base.den;
1935 st->r_frame_rate.den = st->time_base.num;
1938 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1939 if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
1940 codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
1941 if (codec_identified[st->index]) {
1942 st->need_parsing = AVSTREAM_PARSE_FULL;
1945 if(!st->codec->bits_per_sample)
1946 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1950 av_estimate_timings(ic, old_offset);
1952 for(i=0;i<ic->nb_streams;i++) {
1953 st = ic->streams[i];
1954 if (codec_identified[st->index]) {
1955 av_read_frame_flush(ic);
1956 av_seek_frame(ic, st->index, 0.0, 0);
1957 url_fseek(&ic->pb, ic->data_offset, SEEK_SET);
1962 /* correct DTS for b frame streams with no timestamps */
1963 for(i=0;i<ic->nb_streams;i++) {
1964 st = ic->streams[i];
1965 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1967 ppktl = &ic->packet_buffer;
1969 if(ppkt1->stream_index != i)
1971 if(ppkt1->pkt->dts < 0)
1973 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
1975 ppkt1->pkt->dts -= delta;
1980 st->cur_dts -= delta;
1986 av_free(duration_error);
1987 for(i=0;i<MAX_STREAMS;i++){
1988 av_freep(&(probe_data[i].buf));
1994 /*******************************************************/
1996 int av_read_play(AVFormatContext *s)
1998 if (!s->iformat->read_play)
1999 return AVERROR(ENOSYS);
2000 return s->iformat->read_play(s);
2003 int av_read_pause(AVFormatContext *s)
2005 if (!s->iformat->read_pause)
2006 return AVERROR(ENOSYS);
2007 return s->iformat->read_pause(s);
2010 void av_close_input_file(AVFormatContext *s)
2012 int i, must_open_file;
2015 /* free previous packet */
2016 if (s->cur_st && s->cur_st->parser)
2017 av_free_packet(&s->cur_pkt);
2019 if (s->iformat->read_close)
2020 s->iformat->read_close(s);
2021 for(i=0;i<s->nb_streams;i++) {
2022 /* free all data in a stream component */
2025 av_parser_close(st->parser);
2027 av_free(st->index_entries);
2028 av_free(st->codec->extradata);
2032 flush_packet_queue(s);
2034 if (s->iformat->flags & AVFMT_NOFILE) {
2037 if (must_open_file) {
2040 av_freep(&s->priv_data);
2044 AVStream *av_new_stream(AVFormatContext *s, int id)
2049 if (s->nb_streams >= MAX_STREAMS)
2052 st = av_mallocz(sizeof(AVStream));
2056 st->codec= avcodec_alloc_context();
2058 /* no default bitrate if decoding */
2059 st->codec->bit_rate = 0;
2061 st->index = s->nb_streams;
2063 st->start_time = AV_NOPTS_VALUE;
2064 st->duration = AV_NOPTS_VALUE;
2065 st->cur_dts = AV_NOPTS_VALUE;
2067 /* default pts settings is MPEG like */
2068 av_set_pts_info(st, 33, 1, 90000);
2069 st->last_IP_pts = AV_NOPTS_VALUE;
2070 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2071 st->pts_buffer[i]= AV_NOPTS_VALUE;
2073 s->streams[s->nb_streams++] = st;
2077 /************************************************************/
2078 /* output media file */
2080 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2084 if (s->oformat->priv_data_size > 0) {
2085 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2087 return AVERROR(ENOMEM);
2089 s->priv_data = NULL;
2091 if (s->oformat->set_parameters) {
2092 ret = s->oformat->set_parameters(s, ap);
2099 int av_write_header(AVFormatContext *s)
2104 // some sanity checks
2105 for(i=0;i<s->nb_streams;i++) {
2108 switch (st->codec->codec_type) {
2109 case CODEC_TYPE_AUDIO:
2110 if(st->codec->sample_rate<=0){
2111 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2115 case CODEC_TYPE_VIDEO:
2116 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2117 av_log(s, AV_LOG_ERROR, "time base not set\n");
2120 if(st->codec->width<=0 || st->codec->height<=0){
2121 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2127 if(s->oformat->codec_tag){
2128 if(st->codec->codec_tag){
2130 //check that tag + id is in the table
2131 //if neither is in the table -> ok
2132 //if tag is in the table with another id -> FAIL
2133 //if id is in the table with another tag -> FAIL unless strict < ?
2135 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2139 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2140 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2142 return AVERROR(ENOMEM);
2145 if(s->oformat->write_header){
2146 ret = s->oformat->write_header(s);
2151 /* init PTS generation */
2152 for(i=0;i<s->nb_streams;i++) {
2153 int64_t den = AV_NOPTS_VALUE;
2156 switch (st->codec->codec_type) {
2157 case CODEC_TYPE_AUDIO:
2158 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2160 case CODEC_TYPE_VIDEO:
2161 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2166 if (den != AV_NOPTS_VALUE) {
2168 return AVERROR_INVALIDDATA;
2169 av_frac_init(&st->pts, 0, 0, den);
2175 //FIXME merge with compute_pkt_fields
2176 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2177 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2178 int num, den, frame_size, i;
2180 // av_log(st->codec, 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);
2182 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2185 /* duration field */
2186 if (pkt->duration == 0) {
2187 compute_frame_duration(&num, &den, st, NULL, pkt);
2189 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2193 //XXX/FIXME this is a temporary hack until all encoders output pts
2194 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2196 // pkt->pts= st->cur_dts;
2197 pkt->pts= st->pts.val;
2200 //calculate dts from pts
2201 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2202 st->pts_buffer[0]= pkt->pts;
2203 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2204 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2205 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2206 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2208 pkt->dts= st->pts_buffer[0];
2211 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2212 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2215 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2216 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2220 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2221 st->cur_dts= pkt->dts;
2222 st->pts.val= pkt->dts;
2225 switch (st->codec->codec_type) {
2226 case CODEC_TYPE_AUDIO:
2227 frame_size = get_audio_frame_size(st->codec, pkt->size);
2229 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2230 but it would be better if we had the real timestamps from the encoder */
2231 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2232 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2235 case CODEC_TYPE_VIDEO:
2236 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2244 static void truncate_ts(AVStream *st, AVPacket *pkt){
2245 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2248 // pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2250 if (pkt->pts != AV_NOPTS_VALUE)
2251 pkt->pts &= pts_mask;
2252 if (pkt->dts != AV_NOPTS_VALUE)
2253 pkt->dts &= pts_mask;
2256 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2260 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2261 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2264 truncate_ts(s->streams[pkt->stream_index], pkt);
2266 ret= s->oformat->write_packet(s, pkt);
2268 ret= url_ferror(&s->pb);
2272 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2273 AVPacketList *pktl, **next_point, *this_pktl;
2275 int streams[MAX_STREAMS];
2278 AVStream *st= s->streams[ pkt->stream_index];
2280 // assert(pkt->destruct != av_destruct_packet); //FIXME
2282 this_pktl = av_mallocz(sizeof(AVPacketList));
2283 this_pktl->pkt= *pkt;
2284 if(pkt->destruct == av_destruct_packet)
2285 pkt->destruct= NULL; // non shared -> must keep original from being freed
2287 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2289 next_point = &s->packet_buffer;
2291 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2292 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2293 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2294 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2296 next_point= &(*next_point)->next;
2298 this_pktl->next= *next_point;
2299 *next_point= this_pktl;
2302 memset(streams, 0, sizeof(streams));
2303 pktl= s->packet_buffer;
2305 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2306 if(streams[ pktl->pkt.stream_index ] == 0)
2308 streams[ pktl->pkt.stream_index ]++;
2312 if(s->nb_streams == stream_count || (flush && stream_count)){
2313 pktl= s->packet_buffer;
2316 s->packet_buffer= pktl->next;
2320 av_init_packet(out);
2326 * Interleaves a AVPacket correctly so it can be muxed.
2327 * @param out the interleaved packet will be output here
2328 * @param in the input packet
2329 * @param flush 1 if no further packets are available as input and all
2330 * remaining packets should be output
2331 * @return 1 if a packet was output, 0 if no packet could be output,
2332 * < 0 if an error occured
2334 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2335 if(s->oformat->interleave_packet)
2336 return s->oformat->interleave_packet(s, out, in, flush);
2338 return av_interleave_packet_per_dts(s, out, in, flush);
2341 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2342 AVStream *st= s->streams[ pkt->stream_index];
2344 //FIXME/XXX/HACK drop zero sized packets
2345 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2348 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2349 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2352 if(pkt->dts == AV_NOPTS_VALUE)
2357 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2358 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2361 truncate_ts(s->streams[opkt.stream_index], &opkt);
2362 ret= s->oformat->write_packet(s, &opkt);
2364 av_free_packet(&opkt);
2369 if(url_ferror(&s->pb))
2370 return url_ferror(&s->pb);
2374 int av_write_trailer(AVFormatContext *s)
2380 ret= av_interleave_packet(s, &pkt, NULL, 1);
2381 if(ret<0) //FIXME cleanup needed for ret<0 ?
2386 truncate_ts(s->streams[pkt.stream_index], &pkt);
2387 ret= s->oformat->write_packet(s, &pkt);
2389 av_free_packet(&pkt);
2393 if(url_ferror(&s->pb))
2397 if(s->oformat->write_trailer)
2398 ret = s->oformat->write_trailer(s);
2401 ret=url_ferror(&s->pb);
2402 for(i=0;i<s->nb_streams;i++)
2403 av_freep(&s->streams[i]->priv_data);
2404 av_freep(&s->priv_data);
2408 /* "user interface" functions */
2410 void dump_format(AVFormatContext *ic,
2418 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2419 is_output ? "Output" : "Input",
2421 is_output ? ic->oformat->name : ic->iformat->name,
2422 is_output ? "to" : "from", url);
2424 av_log(NULL, AV_LOG_INFO, " Duration: ");
2425 if (ic->duration != AV_NOPTS_VALUE) {
2426 int hours, mins, secs, us;
2427 secs = ic->duration / AV_TIME_BASE;
2428 us = ic->duration % AV_TIME_BASE;
2433 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2434 (10 * us) / AV_TIME_BASE);
2436 av_log(NULL, AV_LOG_INFO, "N/A");
2438 if (ic->start_time != AV_NOPTS_VALUE) {
2440 av_log(NULL, AV_LOG_INFO, ", start: ");
2441 secs = ic->start_time / AV_TIME_BASE;
2442 us = ic->start_time % AV_TIME_BASE;
2443 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2444 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2446 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2448 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2450 av_log(NULL, AV_LOG_INFO, "N/A");
2452 av_log(NULL, AV_LOG_INFO, "\n");
2454 for(i=0;i<ic->nb_streams;i++) {
2455 AVStream *st = ic->streams[i];
2456 int g= ff_gcd(st->time_base.num, st->time_base.den);
2457 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2458 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2459 /* the pid is an important information, so we display it */
2460 /* XXX: add a generic system */
2462 flags = ic->oformat->flags;
2464 flags = ic->iformat->flags;
2465 if (flags & AVFMT_SHOW_IDS) {
2466 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2468 if (strlen(st->language) > 0) {
2469 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2471 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2472 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2473 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2474 if(st->r_frame_rate.den && st->r_frame_rate.num)
2475 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2476 /* else if(st->time_base.den && st->time_base.num)
2477 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2479 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2481 av_log(NULL, AV_LOG_INFO, "\n");
2485 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2487 return av_parse_video_frame_size(width_ptr, height_ptr, str);
2490 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2492 AVRational frame_rate;
2493 int ret = av_parse_video_frame_rate(&frame_rate, arg);
2494 *frame_rate_num= frame_rate.num;
2495 *frame_rate_den= frame_rate.den;
2500 * gets the current time in micro seconds.
2502 int64_t av_gettime(void)
2505 gettimeofday(&tv,NULL);
2506 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2509 int64_t parse_date(const char *datestr, int duration)
2515 static const char *date_fmt[] = {
2519 static const char *time_fmt[] = {
2529 time_t now = time(0);
2531 len = strlen(datestr);
2533 lastch = datestr[len - 1];
2536 is_utc = (lastch == 'z' || lastch == 'Z');
2538 memset(&dt, 0, sizeof(dt));
2543 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2544 q = small_strptime(p, date_fmt[i], &dt);
2554 dt = *localtime(&now);
2556 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2561 if (*p == 'T' || *p == 't' || *p == ' ')
2564 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2565 q = small_strptime(p, time_fmt[i], &dt);
2575 q = small_strptime(p, time_fmt[0], &dt);
2577 dt.tm_sec = strtol(p, (char **)&q, 10);
2583 /* Now we have all the fields that we can get */
2588 return now * INT64_C(1000000);
2592 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2594 dt.tm_isdst = -1; /* unknown */
2607 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2610 val += n * (*q - '0');
2614 return negative ? -t : t;
2617 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2627 while (*p != '\0' && *p != '=' && *p != '&') {
2628 if ((q - tag) < sizeof(tag) - 1)
2636 while (*p != '&' && *p != '\0') {
2637 if ((q - arg) < arg_size - 1) {
2647 if (!strcmp(tag, tag1))
2656 int av_get_frame_filename(char *buf, int buf_size,
2657 const char *path, int number)
2660 char *q, buf1[20], c;
2661 int nd, len, percentd_found;
2673 while (isdigit(*p)) {
2674 nd = nd * 10 + *p++ - '0';
2677 } while (isdigit(c));
2686 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2688 if ((q - buf + len) > buf_size - 1)
2690 memcpy(q, buf1, len);
2698 if ((q - buf) < buf_size - 1)
2702 if (!percentd_found)
2711 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2714 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2716 for(i=0;i<size;i+=16) {
2723 PRINT(" %02x", buf[i+j]);
2728 for(j=0;j<len;j++) {
2730 if (c < ' ' || c > '~')
2739 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2741 hex_dump_internal(NULL, f, 0, buf, size);
2744 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2746 hex_dump_internal(avcl, NULL, level, buf, size);
2749 //FIXME needs to know the time_base
2750 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2752 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2753 PRINT("stream #%d:\n", pkt->stream_index);
2754 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2755 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2756 /* DTS is _always_ valid after av_read_frame() */
2758 if (pkt->dts == AV_NOPTS_VALUE)
2761 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2762 /* PTS may be not known if B frames are present */
2764 if (pkt->pts == AV_NOPTS_VALUE)
2767 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2769 PRINT(" size=%d\n", pkt->size);
2772 av_hex_dump(f, pkt->data, pkt->size);
2775 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2777 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2780 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2782 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2785 void url_split(char *proto, int proto_size,
2786 char *authorization, int authorization_size,
2787 char *hostname, int hostname_size,
2789 char *path, int path_size,
2800 while (*p != ':' && *p != '\0') {
2801 if ((q - proto) < proto_size - 1)
2807 if (authorization_size > 0)
2808 authorization[0] = '\0';
2812 if (hostname_size > 0)
2816 char *at,*slash; // PETR: position of '@' character and '/' character
2823 at = strchr(p,'@'); // PETR: get the position of '@'
2824 slash = strchr(p,'/'); // PETR: get position of '/' - end of hostname
2825 if (at && slash && at > slash) at = NULL; // PETR: not interested in '@' behind '/'
2827 q = at ? authorization : hostname; // PETR: if '@' exists starting with auth.
2829 while ((at || *p != ':') && *p != '/' && *p != '?' && *p != '\0') { // PETR:
2830 if (*p == '@') { // PETR: passed '@'
2831 if (authorization_size > 0)
2835 } else if (!at) { // PETR: hostname
2836 if ((q - hostname) < hostname_size - 1)
2839 if ((q - authorization) < authorization_size - 1)
2844 if (hostname_size > 0)
2848 port = strtoul(p, (char **)&p, 10);
2853 av_strlcpy(path, p, path_size);
2856 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2857 int pts_num, int pts_den)
2859 s->pts_wrap_bits = pts_wrap_bits;
2860 s->time_base.num = pts_num;
2861 s->time_base.den = pts_den;
2864 /* fraction handling */
2867 * f = val + (num / den) + 0.5.
2869 * 'num' is normalized so that it is such as 0 <= num < den.
2871 * @param f fractional number
2872 * @param val integer value
2873 * @param num must be >= 0
2874 * @param den must be >= 1
2876 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2889 * Fractionnal addition to f: f = f + (incr / f->den).
2891 * @param f fractional number
2892 * @param incr increment, can be positive or negative
2894 static void av_frac_add(AVFrac *f, int64_t incr)
2898 num = f->num + incr;
2901 f->val += num / den;
2907 } else if (num >= den) {
2908 f->val += num / den;