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
32 * @file libavformat/utils.c
33 * Various utility functions for using ffmpeg library.
36 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den);
37 static void av_frac_add(AVFrac *f, int64_t incr);
39 /** head of registered input format linked list. */
40 AVInputFormat *first_iformat = NULL;
41 /** head of registered output format linked list. */
42 AVOutputFormat *first_oformat = NULL;
44 void av_register_input_format(AVInputFormat *format)
48 while (*p != NULL) p = &(*p)->next;
53 void av_register_output_format(AVOutputFormat *format)
57 while (*p != NULL) p = &(*p)->next;
62 int match_ext(const char *filename, const char *extensions)
70 ext = strrchr(filename, '.');
76 while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
79 if (!strcasecmp(ext1, ext))
89 AVOutputFormat *guess_format(const char *short_name, const char *filename,
90 const char *mime_type)
92 AVOutputFormat *fmt, *fmt_found;
95 /* specific test for image sequences */
96 #ifdef CONFIG_IMAGE2_MUXER
97 if (!short_name && filename &&
98 av_filename_number_test(filename) &&
99 av_guess_image2_codec(filename) != CODEC_ID_NONE) {
100 return guess_format("image2", NULL, NULL);
103 /* find the proper file type */
107 while (fmt != NULL) {
109 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
111 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
113 if (filename && fmt->extensions &&
114 match_ext(filename, fmt->extensions)) {
117 if (score > score_max) {
126 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
127 const char *mime_type)
129 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
132 AVOutputFormat *stream_fmt;
133 char stream_format_name[64];
135 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
136 stream_fmt = guess_format(stream_format_name, NULL, NULL);
145 enum CodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
146 const char *filename, const char *mime_type, enum CodecType type){
147 if(type == CODEC_TYPE_VIDEO){
148 enum CodecID codec_id= CODEC_ID_NONE;
150 #ifdef CONFIG_IMAGE2_MUXER
151 if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
152 codec_id= av_guess_image2_codec(filename);
155 if(codec_id == CODEC_ID_NONE)
156 codec_id= fmt->video_codec;
158 }else if(type == CODEC_TYPE_AUDIO)
159 return fmt->audio_codec;
161 return CODEC_ID_NONE;
164 AVInputFormat *av_find_input_format(const char *short_name)
167 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
168 if (!strcmp(fmt->name, short_name))
174 /* memory handling */
176 void av_destruct_packet(AVPacket *pkt)
179 pkt->data = NULL; pkt->size = 0;
182 void av_init_packet(AVPacket *pkt)
184 pkt->pts = AV_NOPTS_VALUE;
185 pkt->dts = AV_NOPTS_VALUE;
189 pkt->stream_index = 0;
190 pkt->destruct= av_destruct_packet_nofree;
193 int av_new_packet(AVPacket *pkt, int size)
196 if((unsigned)size > (unsigned)size + FF_INPUT_BUFFER_PADDING_SIZE)
197 return AVERROR(ENOMEM);
198 data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
200 return AVERROR(ENOMEM);
201 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
206 pkt->destruct = av_destruct_packet;
210 int av_get_packet(ByteIOContext *s, AVPacket *pkt, int size)
212 int ret= av_new_packet(pkt, size);
217 pkt->pos= url_ftell(s);
219 ret= get_buffer(s, pkt->data, size);
228 int av_dup_packet(AVPacket *pkt)
230 if (pkt->destruct != av_destruct_packet) {
232 /* we duplicate the packet and don't forget to put the padding
234 if((unsigned)pkt->size > (unsigned)pkt->size + FF_INPUT_BUFFER_PADDING_SIZE)
235 return AVERROR(ENOMEM);
236 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
238 return AVERROR(ENOMEM);
240 memcpy(data, pkt->data, pkt->size);
241 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
243 pkt->destruct = av_destruct_packet;
248 int av_filename_number_test(const char *filename)
251 return filename && (av_get_frame_filename(buf, sizeof(buf), filename, 1)>=0);
254 static AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
256 AVInputFormat *fmt1, *fmt;
260 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
261 if (!is_opened == !(fmt1->flags & AVFMT_NOFILE))
264 if (fmt1->read_probe) {
265 score = fmt1->read_probe(pd);
266 } else if (fmt1->extensions) {
267 if (match_ext(pd->filename, fmt1->extensions)) {
271 if (score > *score_max) {
279 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened){
281 return av_probe_input_format2(pd, is_opened, &score);
284 /************************************************************/
285 /* input media file */
288 * Open a media file from an IO stream. 'fmt' must be specified.
290 static const char* format_to_name(void* ptr)
292 AVFormatContext* fc = (AVFormatContext*) ptr;
293 if(fc->iformat) return fc->iformat->name;
294 else if(fc->oformat) return fc->oformat->name;
298 #define OFFSET(x) offsetof(AVFormatContext,x)
299 #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
300 //these names are too long to be readable
301 #define E AV_OPT_FLAG_ENCODING_PARAM
302 #define D AV_OPT_FLAG_DECODING_PARAM
304 static const AVOption options[]={
305 {"probesize", NULL, OFFSET(probesize), FF_OPT_TYPE_INT, 32000, 32, INT_MAX, D}, /* 32000 from mpegts.c: 1.0 second at 24Mbit/s */
306 {"muxrate", "set mux rate", OFFSET(mux_rate), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
307 {"packetsize", "set packet size", OFFSET(packet_size), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
308 {"fflags", NULL, OFFSET(flags), FF_OPT_TYPE_FLAGS, DEFAULT, INT_MIN, INT_MAX, D|E, "fflags"},
309 {"ignidx", "ignore index", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_IGNIDX, INT_MIN, INT_MAX, D, "fflags"},
310 {"genpts", "generate pts", 0, FF_OPT_TYPE_CONST, AVFMT_FLAG_GENPTS, INT_MIN, INT_MAX, D, "fflags"},
311 {"track", " set the track number", OFFSET(track), FF_OPT_TYPE_INT, DEFAULT, 0, INT_MAX, E},
312 {"year", "set the year", OFFSET(year), FF_OPT_TYPE_INT, DEFAULT, INT_MIN, INT_MAX, E},
313 {"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},
321 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name, options };
323 static void avformat_get_context_defaults(AVFormatContext *s)
325 memset(s, 0, sizeof(AVFormatContext));
327 s->av_class = &av_format_context_class;
329 av_opt_set_defaults(s);
332 AVFormatContext *av_alloc_format_context(void)
335 ic = av_malloc(sizeof(AVFormatContext));
337 avformat_get_context_defaults(ic);
338 ic->av_class = &av_format_context_class;
342 int av_open_input_stream(AVFormatContext **ic_ptr,
343 ByteIOContext *pb, const char *filename,
344 AVInputFormat *fmt, AVFormatParameters *ap)
348 AVFormatParameters default_ap;
352 memset(ap, 0, sizeof(default_ap));
355 if(!ap->prealloced_context)
356 ic = av_alloc_format_context();
360 err = AVERROR(ENOMEM);
366 ic->duration = AV_NOPTS_VALUE;
367 ic->start_time = AV_NOPTS_VALUE;
368 av_strlcpy(ic->filename, filename, sizeof(ic->filename));
370 /* allocate private data */
371 if (fmt->priv_data_size > 0) {
372 ic->priv_data = av_mallocz(fmt->priv_data_size);
373 if (!ic->priv_data) {
374 err = AVERROR(ENOMEM);
378 ic->priv_data = NULL;
381 err = ic->iformat->read_header(ic, ap);
385 if (pb && !ic->data_offset)
386 ic->data_offset = url_ftell(&ic->pb);
392 av_freep(&ic->priv_data);
399 /** Size of probe buffer, for guessing file type from file contents. */
400 #define PROBE_BUF_MIN 2048
401 #define PROBE_BUF_MAX (1<<20)
403 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
406 AVFormatParameters *ap)
408 int err, must_open_file, file_opened, probe_size;
409 AVProbeData probe_data, *pd = &probe_data;
410 ByteIOContext pb1, *pb = &pb1;
415 pd->filename = filename;
420 /* guess format if no file can be opened */
421 fmt = av_probe_input_format(pd, 0);
424 /* do not open file if the format does not need it. XXX: specific
425 hack needed to handle RTSP/TCP */
427 if (fmt && (fmt->flags & AVFMT_NOFILE)) {
429 pb= NULL; //FIXME this or memset(pb, 0, sizeof(ByteIOContext)); otherwise it is uninitialized
432 if (!fmt || must_open_file) {
433 /* if no file needed do not try to open one */
434 if ((err=url_fopen(pb, filename, URL_RDONLY)) < 0) {
439 url_setbufsize(pb, buf_size);
442 for(probe_size= PROBE_BUF_MIN; probe_size<=PROBE_BUF_MAX && !fmt; probe_size<<=1){
443 int score= probe_size < PROBE_BUF_MAX ? AVPROBE_SCORE_MAX/4 : 0;
444 /* read probe data */
445 pd->buf= av_realloc(pd->buf, probe_size + AVPROBE_PADDING_SIZE);
446 pd->buf_size = get_buffer(pb, pd->buf, probe_size);
447 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_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 (!strcmp(fmt->name, "redir")) {
471 int redir_open(AVFormatContext **ic_ptr, ByteIOContext *f);
472 err = redir_open(ic_ptr, pb);
478 /* check filename in case of an image number is expected */
479 if (fmt->flags & AVFMT_NEEDNUMBER) {
480 if (!av_filename_number_test(filename)) {
481 err = AVERROR_NUMEXPECTED;
485 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
498 /*******************************************************/
500 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
503 return s->iformat->read_packet(s, pkt);
506 /**********************************************************/
509 * Get the number of samples of an audio frame. Return (-1) if error.
511 static int get_audio_frame_size(AVCodecContext *enc, int size)
515 if (enc->frame_size <= 1) {
516 int bits_per_sample = av_get_bits_per_sample(enc->codec_id);
518 if (bits_per_sample) {
519 if (enc->channels == 0)
521 frame_size = (size << 3) / (bits_per_sample * enc->channels);
523 /* used for example by ADPCM codecs */
524 if (enc->bit_rate == 0)
526 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
529 frame_size = enc->frame_size;
536 * Return the frame duration in seconds, return 0 if not available.
538 static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
539 AVCodecParserContext *pc, AVPacket *pkt)
545 switch(st->codec->codec_type) {
546 case CODEC_TYPE_VIDEO:
547 if(st->time_base.num*1000LL > st->time_base.den){
548 *pnum = st->time_base.num;
549 *pden = st->time_base.den;
550 }else if(st->codec->time_base.num*1000LL > st->codec->time_base.den){
551 *pnum = st->codec->time_base.num;
552 *pden = st->codec->time_base.den;
553 if (pc && pc->repeat_pict) {
555 *pnum = (*pnum) * (2 + pc->repeat_pict);
559 case CODEC_TYPE_AUDIO:
560 frame_size = get_audio_frame_size(st->codec, pkt->size);
564 *pden = st->codec->sample_rate;
571 static int is_intra_only(AVCodecContext *enc){
572 if(enc->codec_type == CODEC_TYPE_AUDIO){
574 }else if(enc->codec_type == CODEC_TYPE_VIDEO){
575 switch(enc->codec_id){
577 case CODEC_ID_MJPEGB:
579 case CODEC_ID_RAWVIDEO:
580 case CODEC_ID_DVVIDEO:
581 case CODEC_ID_HUFFYUV:
582 case CODEC_ID_FFVHUFF:
593 static void update_initial_timestamps(AVFormatContext *s, int stream_index,
594 int64_t dts, int64_t pts)
596 AVStream *st= s->streams[stream_index];
597 AVPacketList *pktl= s->packet_buffer;
599 if(st->first_dts != AV_NOPTS_VALUE || dts == AV_NOPTS_VALUE)
602 st->first_dts= dts - st->cur_dts;
605 for(; pktl; pktl= pktl->next){
606 if(pktl->pkt.stream_index != stream_index)
608 //FIXME think more about this check
609 if(pktl->pkt.pts != AV_NOPTS_VALUE && pktl->pkt.pts == pktl->pkt.dts)
610 pktl->pkt.pts += st->first_dts;
612 if(pktl->pkt.dts != AV_NOPTS_VALUE)
613 pktl->pkt.dts += st->first_dts;
615 if(st->start_time == AV_NOPTS_VALUE && pktl->pkt.pts != AV_NOPTS_VALUE)
616 st->start_time= pktl->pkt.pts;
618 if (st->start_time == AV_NOPTS_VALUE)
619 st->start_time = pts;
622 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
623 AVCodecParserContext *pc, AVPacket *pkt)
625 int num, den, presentation_delayed, delay, i;
628 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
629 /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
630 pkt->dts -= 1LL<<st->pts_wrap_bits;
633 if (pkt->duration == 0) {
634 compute_frame_duration(&num, &den, st, pc, pkt);
636 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
640 /* correct timestamps with byte offset if demuxers only have timestamps on packet boundaries */
641 if(pc && st->need_parsing == AVSTREAM_PARSE_TIMESTAMPS && pkt->size){
642 /* this will estimate bitrate based on this frame's duration and size */
643 offset = av_rescale(pc->offset, pkt->duration, pkt->size);
644 if(pkt->pts != AV_NOPTS_VALUE)
646 if(pkt->dts != AV_NOPTS_VALUE)
650 if(is_intra_only(st->codec))
651 pkt->flags |= PKT_FLAG_KEY;
653 /* do we have a video B frame ? */
654 delay= st->codec->has_b_frames;
655 presentation_delayed = 0;
656 /* XXX: need has_b_frame, but cannot get it if the codec is
659 pc && pc->pict_type != FF_B_TYPE)
660 presentation_delayed = 1;
661 /* This may be redundant, but it should not hurt. */
662 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts > pkt->dts)
663 presentation_delayed = 1;
665 if(st->cur_dts == AV_NOPTS_VALUE){
666 st->cur_dts = 0; //FIXME maybe set it to 0 during init
669 // 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);
670 /* interpolate PTS and DTS if they are not present */
672 if (presentation_delayed) {
673 /* DTS = decompression time stamp */
674 /* PTS = presentation time stamp */
675 if (pkt->dts == AV_NOPTS_VALUE)
676 pkt->dts = st->last_IP_pts;
677 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts);
678 if (pkt->dts == AV_NOPTS_VALUE)
679 pkt->dts = st->cur_dts;
681 /* this is tricky: the dts must be incremented by the duration
682 of the frame we are displaying, i.e. the last I or P frame */
683 if (st->last_IP_duration == 0)
684 st->last_IP_duration = pkt->duration;
685 st->cur_dts = pkt->dts + st->last_IP_duration;
686 st->last_IP_duration = pkt->duration;
687 st->last_IP_pts= pkt->pts;
688 /* cannot compute PTS if not present (we can compute it only
689 by knowing the futur */
690 } else if(pkt->pts != AV_NOPTS_VALUE || pkt->dts != AV_NOPTS_VALUE || pkt->duration){
691 if(pkt->pts != AV_NOPTS_VALUE && pkt->duration){
692 int64_t old_diff= FFABS(st->cur_dts - pkt->duration - pkt->pts);
693 int64_t new_diff= FFABS(st->cur_dts - pkt->pts);
694 if(old_diff < new_diff && old_diff < (pkt->duration>>3)){
695 pkt->pts += pkt->duration;
696 // 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);
700 /* presentation is not delayed : PTS and DTS are the same */
701 if(pkt->pts == AV_NOPTS_VALUE)
703 update_initial_timestamps(s, pkt->stream_index, pkt->pts, pkt->pts);
704 if(pkt->pts == AV_NOPTS_VALUE)
705 pkt->pts = st->cur_dts;
707 st->cur_dts = pkt->pts + pkt->duration;
711 if(pkt->pts != AV_NOPTS_VALUE){
712 st->pts_buffer[0]= pkt->pts;
713 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
714 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
715 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
716 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
717 if(pkt->dts == AV_NOPTS_VALUE)
718 pkt->dts= st->pts_buffer[0];
720 update_initial_timestamps(s, pkt->stream_index, pkt->dts, pkt->pts); // this should happen on the first packet
722 if(pkt->dts > st->cur_dts)
723 st->cur_dts = pkt->dts;
726 // 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);
731 /* key frame computation */
732 if (pc->pict_type == FF_I_TYPE)
733 pkt->flags |= PKT_FLAG_KEY;
737 void av_destruct_packet_nofree(AVPacket *pkt)
739 pkt->data = NULL; pkt->size = 0;
742 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
750 /* select current input stream component */
753 if (!st->need_parsing || !st->parser) {
754 /* no parsing needed: we just output the packet as is */
755 /* raw data support */
757 compute_pkt_fields(s, st, NULL, pkt);
760 } else if (s->cur_len > 0 && st->discard < AVDISCARD_ALL) {
761 len = av_parser_parse(st->parser, st->codec, &pkt->data, &pkt->size,
762 s->cur_ptr, s->cur_len,
763 s->cur_pkt.pts, s->cur_pkt.dts);
764 s->cur_pkt.pts = AV_NOPTS_VALUE;
765 s->cur_pkt.dts = AV_NOPTS_VALUE;
766 /* increment read pointer */
770 /* return packet if any */
773 pkt->pos = s->cur_pkt.pos; // Isn't quite accurate but close.
775 pkt->stream_index = st->index;
776 pkt->pts = st->parser->pts;
777 pkt->dts = st->parser->dts;
778 pkt->destruct = av_destruct_packet_nofree;
779 compute_pkt_fields(s, st, st->parser, pkt);
781 if((s->iformat->flags & AVFMT_GENERIC_INDEX) && pkt->flags & PKT_FLAG_KEY){
782 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
783 0, 0, AVINDEX_KEYFRAME);
790 av_free_packet(&s->cur_pkt);
794 /* read next packet */
795 ret = av_read_packet(s, &s->cur_pkt);
797 if (ret == AVERROR(EAGAIN))
799 /* return the last frames, if any */
800 for(i = 0; i < s->nb_streams; i++) {
802 if (st->parser && st->need_parsing) {
803 av_parser_parse(st->parser, st->codec,
804 &pkt->data, &pkt->size,
806 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
811 /* no more packets: really terminates parsing */
815 st = s->streams[s->cur_pkt.stream_index];
816 if(st->codec->debug & FF_DEBUG_PTS)
817 av_log(s, AV_LOG_DEBUG, "av_read_packet stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
818 s->cur_pkt.stream_index,
824 s->cur_ptr = s->cur_pkt.data;
825 s->cur_len = s->cur_pkt.size;
826 if (st->need_parsing && !st->parser) {
827 st->parser = av_parser_init(st->codec->codec_id);
829 /* no parser available : just output the raw packets */
830 st->need_parsing = AVSTREAM_PARSE_NONE;
831 }else if(st->need_parsing == AVSTREAM_PARSE_HEADERS){
832 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
834 if(st->parser && (s->iformat->flags & AVFMT_GENERIC_INDEX)){
835 st->parser->last_frame_offset=
836 st->parser->cur_offset= s->cur_pkt.pos;
841 if(st->codec->debug & FF_DEBUG_PTS)
842 av_log(s, AV_LOG_DEBUG, "av_read_frame_internal stream=%d, pts=%"PRId64", dts=%"PRId64", size=%d\n",
851 static AVPacket *add_to_pktbuf(AVFormatContext *s, AVPacket *pkt){
852 AVPacketList *pktl= s->packet_buffer;
853 AVPacketList **plast_pktl= &s->packet_buffer;
855 while(*plast_pktl) plast_pktl= &(*plast_pktl)->next; //FIXME maybe maintain pointer to the last?
857 pktl = av_mallocz(sizeof(AVPacketList));
861 /* add the packet in the buffered packet list */
867 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
871 const int genpts= s->flags & AVFMT_FLAG_GENPTS;
874 pktl = s->packet_buffer;
876 AVPacket *next_pkt= &pktl->pkt;
878 if(genpts && next_pkt->dts != AV_NOPTS_VALUE){
879 while(pktl && next_pkt->pts == AV_NOPTS_VALUE){
880 if( pktl->pkt.stream_index == next_pkt->stream_index
881 && next_pkt->dts < pktl->pkt.dts
882 && pktl->pkt.pts != pktl->pkt.dts //not b frame
883 /*&& pktl->pkt.dts != AV_NOPTS_VALUE*/){
884 next_pkt->pts= pktl->pkt.dts;
888 pktl = s->packet_buffer;
891 if( next_pkt->pts != AV_NOPTS_VALUE
892 || next_pkt->dts == AV_NOPTS_VALUE
894 /* read packet from packet buffer, if there is data */
896 s->packet_buffer = pktl->next;
902 int ret= av_read_frame_internal(s, pkt);
904 if(pktl && ret != AVERROR(EAGAIN)){
911 if(av_dup_packet(add_to_pktbuf(s, pkt)) < 0)
912 return AVERROR(ENOMEM);
914 assert(!s->packet_buffer);
915 return av_read_frame_internal(s, pkt);
920 /* XXX: suppress the packet queue */
921 static void flush_packet_queue(AVFormatContext *s)
926 pktl = s->packet_buffer;
929 s->packet_buffer = pktl->next;
930 av_free_packet(&pktl->pkt);
935 /*******************************************************/
938 int av_find_default_stream_index(AVFormatContext *s)
943 if (s->nb_streams <= 0)
945 for(i = 0; i < s->nb_streams; i++) {
947 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
955 * Flush the frame reader.
957 static void av_read_frame_flush(AVFormatContext *s)
962 flush_packet_queue(s);
964 /* free previous packet */
966 if (s->cur_st->parser)
967 av_free_packet(&s->cur_pkt);
974 /* for each stream, reset read state */
975 for(i = 0; i < s->nb_streams; i++) {
979 av_parser_close(st->parser);
982 st->last_IP_pts = AV_NOPTS_VALUE;
983 st->cur_dts = AV_NOPTS_VALUE; /* we set the current DTS to an unspecified origin */
987 void av_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp){
990 for(i = 0; i < s->nb_streams; i++) {
991 AVStream *st = s->streams[i];
993 st->cur_dts = av_rescale(timestamp,
994 st->time_base.den * (int64_t)ref_st->time_base.num,
995 st->time_base.num * (int64_t)ref_st->time_base.den);
999 int av_add_index_entry(AVStream *st,
1000 int64_t pos, int64_t timestamp, int size, int distance, int flags)
1002 AVIndexEntry *entries, *ie;
1005 if((unsigned)st->nb_index_entries + 1 >= UINT_MAX / sizeof(AVIndexEntry))
1008 entries = av_fast_realloc(st->index_entries,
1009 &st->index_entries_allocated_size,
1010 (st->nb_index_entries + 1) *
1011 sizeof(AVIndexEntry));
1015 st->index_entries= entries;
1017 index= av_index_search_timestamp(st, timestamp, AVSEEK_FLAG_ANY);
1020 index= st->nb_index_entries++;
1021 ie= &entries[index];
1022 assert(index==0 || ie[-1].timestamp < timestamp);
1024 ie= &entries[index];
1025 if(ie->timestamp != timestamp){
1026 if(ie->timestamp <= timestamp)
1028 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
1029 st->nb_index_entries++;
1030 }else if(ie->pos == pos && distance < ie->min_distance) //do not reduce the distance
1031 distance= ie->min_distance;
1035 ie->timestamp = timestamp;
1036 ie->min_distance= distance;
1043 int av_index_search_timestamp(AVStream *st, int64_t wanted_timestamp,
1046 AVIndexEntry *entries= st->index_entries;
1047 int nb_entries= st->nb_index_entries;
1056 timestamp = entries[m].timestamp;
1057 if(timestamp >= wanted_timestamp)
1059 if(timestamp <= wanted_timestamp)
1062 m= (flags & AVSEEK_FLAG_BACKWARD) ? a : b;
1064 if(!(flags & AVSEEK_FLAG_ANY)){
1065 while(m>=0 && m<nb_entries && !(entries[m].flags & AVINDEX_KEYFRAME)){
1066 m += (flags & AVSEEK_FLAG_BACKWARD) ? -1 : 1;
1077 int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
1078 AVInputFormat *avif= s->iformat;
1079 int64_t pos_min, pos_max, pos, pos_limit;
1080 int64_t ts_min, ts_max, ts;
1084 if (stream_index < 0)
1088 av_log(s, AV_LOG_DEBUG, "read_seek: %d %"PRId64"\n", stream_index, target_ts);
1092 ts_min= AV_NOPTS_VALUE;
1093 pos_limit= -1; //gcc falsely says it may be uninitialized
1095 st= s->streams[stream_index];
1096 if(st->index_entries){
1099 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()
1100 index= FFMAX(index, 0);
1101 e= &st->index_entries[index];
1103 if(e->timestamp <= target_ts || e->pos == e->min_distance){
1105 ts_min= e->timestamp;
1107 av_log(s, AV_LOG_DEBUG, "using cached pos_min=0x%"PRIx64" dts_min=%"PRId64"\n",
1114 index= av_index_search_timestamp(st, target_ts, flags & ~AVSEEK_FLAG_BACKWARD);
1115 assert(index < st->nb_index_entries);
1117 e= &st->index_entries[index];
1118 assert(e->timestamp >= target_ts);
1120 ts_max= e->timestamp;
1121 pos_limit= pos_max - e->min_distance;
1123 av_log(s, AV_LOG_DEBUG, "using cached pos_max=0x%"PRIx64" pos_limit=0x%"PRIx64" dts_max=%"PRId64"\n",
1124 pos_max,pos_limit, ts_max);
1129 pos= av_gen_search(s, stream_index, target_ts, pos_min, pos_max, pos_limit, ts_min, ts_max, flags, &ts, avif->read_timestamp);
1134 url_fseek(&s->pb, pos, SEEK_SET);
1136 av_update_cur_dts(s, st, ts);
1141 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 )){
1143 int64_t start_pos, filesize;
1147 av_log(s, AV_LOG_DEBUG, "gen_seek: %d %"PRId64"\n", stream_index, target_ts);
1150 if(ts_min == AV_NOPTS_VALUE){
1151 pos_min = s->data_offset;
1152 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1153 if (ts_min == AV_NOPTS_VALUE)
1157 if(ts_max == AV_NOPTS_VALUE){
1159 filesize = url_fsize(&s->pb);
1160 pos_max = filesize - 1;
1163 ts_max = read_timestamp(s, stream_index, &pos_max, pos_max + step);
1165 }while(ts_max == AV_NOPTS_VALUE && pos_max >= step);
1166 if (ts_max == AV_NOPTS_VALUE)
1170 int64_t tmp_pos= pos_max + 1;
1171 int64_t tmp_ts= read_timestamp(s, stream_index, &tmp_pos, INT64_MAX);
1172 if(tmp_ts == AV_NOPTS_VALUE)
1176 if(tmp_pos >= filesize)
1182 if(ts_min > ts_max){
1184 }else if(ts_min == ts_max){
1189 while (pos_min < pos_limit) {
1191 av_log(s, AV_LOG_DEBUG, "pos_min=0x%"PRIx64" pos_max=0x%"PRIx64" dts_min=%"PRId64" dts_max=%"PRId64"\n",
1195 assert(pos_limit <= pos_max);
1198 int64_t approximate_keyframe_distance= pos_max - pos_limit;
1199 // interpolate position (better than dichotomy)
1200 pos = av_rescale(target_ts - ts_min, pos_max - pos_min, ts_max - ts_min)
1201 + pos_min - approximate_keyframe_distance;
1202 }else if(no_change==1){
1203 // bisection, if interpolation failed to change min or max pos last time
1204 pos = (pos_min + pos_limit)>>1;
1206 // linear search if bisection failed, can only happen if there are very few or no keframes between min/max
1211 else if(pos > pos_limit)
1215 ts = read_timestamp(s, stream_index, &pos, INT64_MAX); //may pass pos_limit instead of -1
1221 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);
1223 if(ts == AV_NOPTS_VALUE){
1224 av_log(s, AV_LOG_ERROR, "read_timestamp() failed in the middle\n");
1227 assert(ts != AV_NOPTS_VALUE);
1228 if (target_ts <= ts) {
1229 pos_limit = start_pos - 1;
1233 if (target_ts >= ts) {
1239 pos = (flags & AVSEEK_FLAG_BACKWARD) ? pos_min : pos_max;
1240 ts = (flags & AVSEEK_FLAG_BACKWARD) ? ts_min : ts_max;
1243 ts_min = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1245 ts_max = read_timestamp(s, stream_index, &pos_min, INT64_MAX);
1246 av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" %"PRId64"<=%"PRId64"<=%"PRId64"\n",
1247 pos, ts_min, target_ts, ts_max);
1253 static int av_seek_frame_byte(AVFormatContext *s, int stream_index, int64_t pos, int flags){
1254 int64_t pos_min, pos_max;
1258 if (stream_index < 0)
1261 st= s->streams[stream_index];
1264 pos_min = s->data_offset;
1265 pos_max = url_fsize(&s->pb) - 1;
1267 if (pos < pos_min) pos= pos_min;
1268 else if(pos > pos_max) pos= pos_max;
1270 url_fseek(&s->pb, pos, SEEK_SET);
1273 av_update_cur_dts(s, st, ts);
1278 static int av_seek_frame_generic(AVFormatContext *s,
1279 int stream_index, int64_t timestamp, int flags)
1285 st = s->streams[stream_index];
1287 index = av_index_search_timestamp(st, timestamp, flags);
1289 if(index < 0 || index==st->nb_index_entries-1){
1293 if(st->index_entries && st->nb_index_entries){
1294 ie= &st->index_entries[st->nb_index_entries-1];
1295 url_fseek(&s->pb, ie->pos, SEEK_SET);
1296 av_update_cur_dts(s, st, ie->timestamp);
1298 url_fseek(&s->pb, 0, SEEK_SET);
1301 int ret = av_read_frame(s, &pkt);
1304 av_free_packet(&pkt);
1305 if(stream_index == pkt.stream_index){
1306 if((pkt.flags & PKT_FLAG_KEY) && pkt.dts > timestamp)
1310 index = av_index_search_timestamp(st, timestamp, flags);
1315 av_read_frame_flush(s);
1316 if (s->iformat->read_seek){
1317 if(s->iformat->read_seek(s, stream_index, timestamp, flags) >= 0)
1320 ie = &st->index_entries[index];
1321 url_fseek(&s->pb, ie->pos, SEEK_SET);
1323 av_update_cur_dts(s, st, ie->timestamp);
1328 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
1333 av_read_frame_flush(s);
1335 if(flags & AVSEEK_FLAG_BYTE)
1336 return av_seek_frame_byte(s, stream_index, timestamp, flags);
1338 if(stream_index < 0){
1339 stream_index= av_find_default_stream_index(s);
1340 if(stream_index < 0)
1343 st= s->streams[stream_index];
1344 /* timestamp for default must be expressed in AV_TIME_BASE units */
1345 timestamp = av_rescale(timestamp, st->time_base.den, AV_TIME_BASE * (int64_t)st->time_base.num);
1347 st= s->streams[stream_index];
1349 /* first, we try the format specific seek */
1350 if (s->iformat->read_seek)
1351 ret = s->iformat->read_seek(s, stream_index, timestamp, flags);
1358 if(s->iformat->read_timestamp)
1359 return av_seek_frame_binary(s, stream_index, timestamp, flags);
1361 return av_seek_frame_generic(s, stream_index, timestamp, flags);
1364 /*******************************************************/
1367 * Returns TRUE if the stream has accurate duration in any stream.
1369 * @return TRUE if the stream has accurate duration for at least one component.
1371 static int av_has_duration(AVFormatContext *ic)
1376 for(i = 0;i < ic->nb_streams; i++) {
1377 st = ic->streams[i];
1378 if (st->duration != AV_NOPTS_VALUE)
1385 * Estimate the stream timings from the one of each components.
1387 * Also computes the global bitrate if possible.
1389 static void av_update_stream_timings(AVFormatContext *ic)
1391 int64_t start_time, start_time1, end_time, end_time1;
1392 int64_t duration, duration1;
1396 start_time = INT64_MAX;
1397 end_time = INT64_MIN;
1398 duration = INT64_MIN;
1399 for(i = 0;i < ic->nb_streams; i++) {
1400 st = ic->streams[i];
1401 if (st->start_time != AV_NOPTS_VALUE) {
1402 start_time1= av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q);
1403 if (start_time1 < start_time)
1404 start_time = start_time1;
1405 if (st->duration != AV_NOPTS_VALUE) {
1406 end_time1 = start_time1
1407 + av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1408 if (end_time1 > end_time)
1409 end_time = end_time1;
1412 if (st->duration != AV_NOPTS_VALUE) {
1413 duration1 = av_rescale_q(st->duration, st->time_base, AV_TIME_BASE_Q);
1414 if (duration1 > duration)
1415 duration = duration1;
1418 if (start_time != INT64_MAX) {
1419 ic->start_time = start_time;
1420 if (end_time != INT64_MIN) {
1421 if (end_time - start_time > duration)
1422 duration = end_time - start_time;
1425 if (duration != INT64_MIN) {
1426 ic->duration = duration;
1427 if (ic->file_size > 0) {
1428 /* compute the bit rate */
1429 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1430 (double)ic->duration;
1435 static void fill_all_stream_timings(AVFormatContext *ic)
1440 av_update_stream_timings(ic);
1441 for(i = 0;i < ic->nb_streams; i++) {
1442 st = ic->streams[i];
1443 if (st->start_time == AV_NOPTS_VALUE) {
1444 if(ic->start_time != AV_NOPTS_VALUE)
1445 st->start_time = av_rescale_q(ic->start_time, AV_TIME_BASE_Q, st->time_base);
1446 if(ic->duration != AV_NOPTS_VALUE)
1447 st->duration = av_rescale_q(ic->duration, AV_TIME_BASE_Q, st->time_base);
1452 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1454 int64_t filesize, duration;
1458 /* if bit_rate is already set, we believe it */
1459 if (ic->bit_rate == 0) {
1461 for(i=0;i<ic->nb_streams;i++) {
1462 st = ic->streams[i];
1463 bit_rate += st->codec->bit_rate;
1465 ic->bit_rate = bit_rate;
1468 /* if duration is already set, we believe it */
1469 if (ic->duration == AV_NOPTS_VALUE &&
1470 ic->bit_rate != 0 &&
1471 ic->file_size != 0) {
1472 filesize = ic->file_size;
1474 for(i = 0; i < ic->nb_streams; i++) {
1475 st = ic->streams[i];
1476 duration= av_rescale(8*filesize, st->time_base.den, ic->bit_rate*(int64_t)st->time_base.num);
1477 if (st->duration == AV_NOPTS_VALUE)
1478 st->duration = duration;
1484 #define DURATION_MAX_READ_SIZE 250000
1486 /* only usable for MPEG-PS streams */
1487 static void av_estimate_timings_from_pts(AVFormatContext *ic, offset_t old_offset)
1489 AVPacket pkt1, *pkt = &pkt1;
1491 int read_size, i, ret;
1493 int64_t filesize, offset, duration;
1495 /* free previous packet */
1496 if (ic->cur_st && ic->cur_st->parser)
1497 av_free_packet(&ic->cur_pkt);
1500 /* flush packet queue */
1501 flush_packet_queue(ic);
1503 for(i=0;i<ic->nb_streams;i++) {
1504 st = ic->streams[i];
1506 av_parser_close(st->parser);
1511 /* we read the first packets to get the first PTS (not fully
1512 accurate, but it is enough now) */
1513 url_fseek(&ic->pb, 0, SEEK_SET);
1516 if (read_size >= DURATION_MAX_READ_SIZE)
1518 /* if all info is available, we can stop */
1519 for(i = 0;i < ic->nb_streams; i++) {
1520 st = ic->streams[i];
1521 if (st->start_time == AV_NOPTS_VALUE)
1524 if (i == ic->nb_streams)
1527 ret = av_read_packet(ic, pkt);
1530 read_size += pkt->size;
1531 st = ic->streams[pkt->stream_index];
1532 if (pkt->pts != AV_NOPTS_VALUE) {
1533 if (st->start_time == AV_NOPTS_VALUE)
1534 st->start_time = pkt->pts;
1536 av_free_packet(pkt);
1539 /* estimate the end time (duration) */
1540 /* XXX: may need to support wrapping */
1541 filesize = ic->file_size;
1542 offset = filesize - DURATION_MAX_READ_SIZE;
1546 url_fseek(&ic->pb, offset, SEEK_SET);
1549 if (read_size >= DURATION_MAX_READ_SIZE)
1552 ret = av_read_packet(ic, pkt);
1555 read_size += pkt->size;
1556 st = ic->streams[pkt->stream_index];
1557 if (pkt->pts != AV_NOPTS_VALUE &&
1558 st->start_time != AV_NOPTS_VALUE) {
1559 end_time = pkt->pts;
1560 duration = end_time - st->start_time;
1562 if (st->duration == AV_NOPTS_VALUE ||
1563 st->duration < duration)
1564 st->duration = duration;
1567 av_free_packet(pkt);
1570 fill_all_stream_timings(ic);
1572 url_fseek(&ic->pb, old_offset, SEEK_SET);
1573 for(i=0; i<ic->nb_streams; i++){
1575 st->cur_dts= st->first_dts;
1576 st->last_IP_pts = AV_NOPTS_VALUE;
1580 static void av_estimate_timings(AVFormatContext *ic, offset_t old_offset)
1584 /* get the file size, if possible */
1585 if (ic->iformat->flags & AVFMT_NOFILE) {
1588 file_size = url_fsize(&ic->pb);
1592 ic->file_size = file_size;
1594 if ((!strcmp(ic->iformat->name, "mpeg") ||
1595 !strcmp(ic->iformat->name, "mpegts")) &&
1596 file_size && !ic->pb.is_streamed) {
1597 /* get accurate estimate from the PTSes */
1598 av_estimate_timings_from_pts(ic, old_offset);
1599 } else if (av_has_duration(ic)) {
1600 /* at least one components has timings - we use them for all
1602 fill_all_stream_timings(ic);
1604 /* less precise: use bit rate info */
1605 av_estimate_timings_from_bit_rate(ic);
1607 av_update_stream_timings(ic);
1613 for(i = 0;i < ic->nb_streams; i++) {
1614 st = ic->streams[i];
1615 printf("%d: start_time: %0.3f duration: %0.3f\n",
1616 i, (double)st->start_time / AV_TIME_BASE,
1617 (double)st->duration / AV_TIME_BASE);
1619 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1620 (double)ic->start_time / AV_TIME_BASE,
1621 (double)ic->duration / AV_TIME_BASE,
1622 ic->bit_rate / 1000);
1627 static int has_codec_parameters(AVCodecContext *enc)
1630 switch(enc->codec_type) {
1631 case CODEC_TYPE_AUDIO:
1632 val = enc->sample_rate;
1634 case CODEC_TYPE_VIDEO:
1635 val = enc->width && enc->pix_fmt != PIX_FMT_NONE;
1641 return (enc->codec_id != CODEC_ID_NONE && val != 0);
1644 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1648 int got_picture, data_size, ret=0;
1651 if(!st->codec->codec){
1652 codec = avcodec_find_decoder(st->codec->codec_id);
1655 ret = avcodec_open(st->codec, codec);
1660 if(!has_codec_parameters(st->codec)){
1661 switch(st->codec->codec_type) {
1662 case CODEC_TYPE_VIDEO:
1663 ret = avcodec_decode_video(st->codec, &picture,
1664 &got_picture, (uint8_t *)data, size);
1666 case CODEC_TYPE_AUDIO:
1667 data_size = FFMAX(size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1668 samples = av_malloc(data_size);
1671 ret = avcodec_decode_audio2(st->codec, samples,
1672 &data_size, (uint8_t *)data, size);
1683 static int set_codec_from_probe_data(AVStream *st, AVProbeData *pd, int score)
1686 fmt = av_probe_input_format2(pd, 1, &score);
1689 if (strncmp(fmt->name, "mp3", 3) == 0)
1690 st->codec->codec_id = CODEC_ID_MP3;
1691 else if (strncmp(fmt->name, "ac3", 3) == 0)
1692 st->codec->codec_id = CODEC_ID_AC3;
1697 unsigned int codec_get_tag(const AVCodecTag *tags, int id)
1699 while (tags->id != CODEC_ID_NONE) {
1707 enum CodecID codec_get_id(const AVCodecTag *tags, unsigned int tag)
1710 for(i=0; tags[i].id != CODEC_ID_NONE;i++) {
1711 if(tag == tags[i].tag)
1714 for(i=0; tags[i].id != CODEC_ID_NONE; i++) {
1715 if( toupper((tag >> 0)&0xFF) == toupper((tags[i].tag >> 0)&0xFF)
1716 && toupper((tag >> 8)&0xFF) == toupper((tags[i].tag >> 8)&0xFF)
1717 && toupper((tag >>16)&0xFF) == toupper((tags[i].tag >>16)&0xFF)
1718 && toupper((tag >>24)&0xFF) == toupper((tags[i].tag >>24)&0xFF))
1721 return CODEC_ID_NONE;
1724 unsigned int av_codec_get_tag(const AVCodecTag *tags[4], enum CodecID id)
1727 for(i=0; tags && tags[i]; i++){
1728 int tag= codec_get_tag(tags[i], id);
1734 enum CodecID av_codec_get_id(const AVCodecTag *tags[4], unsigned int tag)
1737 for(i=0; tags && tags[i]; i++){
1738 enum CodecID id= codec_get_id(tags[i], tag);
1739 if(id!=CODEC_ID_NONE) return id;
1741 return CODEC_ID_NONE;
1744 /* absolute maximum size we read until we abort */
1745 #define MAX_READ_SIZE 5000000
1747 #define MAX_STD_TIMEBASES (60*12+5)
1748 static int get_std_framerate(int i){
1749 if(i<60*12) return i*1001;
1750 else return ((int[]){24,30,60,12,15})[i-60*12]*1000*12;
1753 int av_find_stream_info(AVFormatContext *ic)
1755 int i, count, ret, read_size, j;
1757 AVPacket pkt1, *pkt;
1758 int64_t last_dts[MAX_STREAMS];
1759 int duration_count[MAX_STREAMS]={0};
1760 double (*duration_error)[MAX_STD_TIMEBASES];
1761 offset_t old_offset = url_ftell(&ic->pb);
1762 int64_t codec_info_duration[MAX_STREAMS]={0};
1763 int codec_info_nb_frames[MAX_STREAMS]={0};
1764 AVProbeData probe_data[MAX_STREAMS];
1765 int codec_identified[MAX_STREAMS]={0};
1767 duration_error = av_mallocz(MAX_STREAMS * sizeof(*duration_error));
1768 if (!duration_error) return AVERROR(ENOMEM);
1770 for(i=0;i<ic->nb_streams;i++) {
1771 st = ic->streams[i];
1772 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
1773 /* if(!st->time_base.num)
1775 if(!st->codec->time_base.num)
1776 st->codec->time_base= st->time_base;
1778 //only for the split stuff
1780 st->parser = av_parser_init(st->codec->codec_id);
1781 if(st->need_parsing == AVSTREAM_PARSE_HEADERS && st->parser){
1782 st->parser->flags |= PARSER_FLAG_COMPLETE_FRAMES;
1787 for(i=0;i<MAX_STREAMS;i++){
1788 last_dts[i]= AV_NOPTS_VALUE;
1791 memset(probe_data, 0, sizeof(probe_data));
1795 /* check if one codec still needs to be handled */
1796 for(i=0;i<ic->nb_streams;i++) {
1797 st = ic->streams[i];
1798 if (!has_codec_parameters(st->codec))
1800 /* variable fps and no guess at the real fps */
1801 if( (st->codec->time_base.den >= 101LL*st->codec->time_base.num || st->codec->codec_id == CODEC_ID_MPEG2VIDEO)
1802 && duration_count[i]<20 && st->codec->codec_type == CODEC_TYPE_VIDEO)
1804 if(st->parser && st->parser->parser->split && !st->codec->extradata)
1806 if(st->first_dts == AV_NOPTS_VALUE)
1809 if (i == ic->nb_streams) {
1810 /* NOTE: if the format has no header, then we need to read
1811 some packets to get most of the streams, so we cannot
1813 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1814 /* if we found the info for all the codecs, we can stop */
1819 /* we did not get all the codec info, but we read too much data */
1820 if (read_size >= MAX_READ_SIZE) {
1825 /* NOTE: a new stream can be added there if no header in file
1826 (AVFMTCTX_NOHEADER) */
1827 ret = av_read_frame_internal(ic, &pkt1);
1830 ret = -1; /* we could not have all the codec parameters before EOF */
1831 for(i=0;i<ic->nb_streams;i++) {
1832 st = ic->streams[i];
1833 if (!has_codec_parameters(st->codec)){
1835 avcodec_string(buf, sizeof(buf), st->codec, 0);
1836 av_log(ic, AV_LOG_INFO, "Could not find codec parameters (%s)\n", buf);
1844 pkt= add_to_pktbuf(ic, &pkt1);
1845 if(av_dup_packet(pkt) < 0)
1846 return AVERROR(ENOMEM);
1848 read_size += pkt->size;
1850 st = ic->streams[pkt->stream_index];
1851 if(codec_info_nb_frames[st->index]>1)
1852 codec_info_duration[st->index] += pkt->duration;
1853 if (pkt->duration != 0)
1854 codec_info_nb_frames[st->index]++;
1857 int index= pkt->stream_index;
1858 int64_t last= last_dts[index];
1859 int64_t duration= pkt->dts - last;
1861 if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && duration>0){
1862 double dur= duration * av_q2d(st->time_base);
1864 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1865 // av_log(NULL, AV_LOG_ERROR, "%f\n", dur);
1866 if(duration_count[index] < 2)
1867 memset(duration_error, 0, MAX_STREAMS * sizeof(*duration_error));
1868 for(i=1; i<MAX_STD_TIMEBASES; i++){
1869 int framerate= get_std_framerate(i);
1870 int ticks= lrintf(dur*framerate/(1001*12));
1871 double error= dur - ticks*1001*12/(double)framerate;
1872 duration_error[index][i] += error*error;
1874 duration_count[index]++;
1876 if(last == AV_NOPTS_VALUE || duration_count[index]<=1)
1877 last_dts[pkt->stream_index]= pkt->dts;
1879 if (st->codec->codec_id == CODEC_ID_NONE) {
1880 AVProbeData *pd = &(probe_data[st->index]);
1881 pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
1882 memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
1883 pd->buf_size += pkt->size;
1884 memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
1887 if(st->parser && st->parser->parser->split && !st->codec->extradata){
1888 int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
1890 st->codec->extradata_size= i;
1891 st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
1892 memcpy(st->codec->extradata, pkt->data, st->codec->extradata_size);
1893 memset(st->codec->extradata + i, 0, FF_INPUT_BUFFER_PADDING_SIZE);
1897 /* if still no information, we try to open the codec and to
1898 decompress the frame. We try to avoid that in most cases as
1899 it takes longer and uses more memory. For MPEG4, we need to
1900 decompress for Quicktime. */
1901 if (!has_codec_parameters(st->codec) /*&&
1902 (st->codec->codec_id == CODEC_ID_FLV1 ||
1903 st->codec->codec_id == CODEC_ID_H264 ||
1904 st->codec->codec_id == CODEC_ID_H263 ||
1905 st->codec->codec_id == CODEC_ID_H261 ||
1906 st->codec->codec_id == CODEC_ID_VORBIS ||
1907 st->codec->codec_id == CODEC_ID_MJPEG ||
1908 st->codec->codec_id == CODEC_ID_PNG ||
1909 st->codec->codec_id == CODEC_ID_PAM ||
1910 st->codec->codec_id == CODEC_ID_PGM ||
1911 st->codec->codec_id == CODEC_ID_PGMYUV ||
1912 st->codec->codec_id == CODEC_ID_PBM ||
1913 st->codec->codec_id == CODEC_ID_PPM ||
1914 st->codec->codec_id == CODEC_ID_SHORTEN ||
1915 (st->codec->codec_id == CODEC_ID_MPEG4 && !st->need_parsing))*/)
1916 try_decode_frame(st, pkt->data, pkt->size);
1918 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) {
1924 // close codecs which where opened in try_decode_frame()
1925 for(i=0;i<ic->nb_streams;i++) {
1926 st = ic->streams[i];
1927 if(st->codec->codec)
1928 avcodec_close(st->codec);
1930 for(i=0;i<ic->nb_streams;i++) {
1931 st = ic->streams[i];
1932 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
1933 if(st->codec->codec_id == CODEC_ID_RAWVIDEO && !st->codec->codec_tag && !st->codec->bits_per_sample)
1934 st->codec->codec_tag= avcodec_pix_fmt_to_codec_tag(st->codec->pix_fmt);
1936 if(duration_count[i]
1937 && (st->codec->time_base.num*101LL <= st->codec->time_base.den || st->codec->codec_id == CODEC_ID_MPEG2VIDEO) /*&&
1938 //FIXME we should not special case mpeg2, but this needs testing with non mpeg2 ...
1939 st->time_base.num*duration_sum[i]/duration_count[i]*101LL > st->time_base.den*/){
1940 double best_error= 2*av_q2d(st->time_base);
1941 best_error= best_error*best_error*duration_count[i]*1000*12*30;
1943 for(j=1; j<MAX_STD_TIMEBASES; j++){
1944 double error= duration_error[i][j] * get_std_framerate(j);
1945 // if(st->codec->codec_type == CODEC_TYPE_VIDEO)
1946 // av_log(NULL, AV_LOG_ERROR, "%f %f\n", get_std_framerate(j) / 12.0/1001, error);
1947 if(error < best_error){
1949 av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, get_std_framerate(j), 12*1001, INT_MAX);
1954 if (!st->r_frame_rate.num){
1955 if( st->codec->time_base.den * (int64_t)st->time_base.num
1956 <= st->codec->time_base.num * (int64_t)st->time_base.den){
1957 st->r_frame_rate.num = st->codec->time_base.den;
1958 st->r_frame_rate.den = st->codec->time_base.num;
1960 st->r_frame_rate.num = st->time_base.den;
1961 st->r_frame_rate.den = st->time_base.num;
1964 }else if(st->codec->codec_type == CODEC_TYPE_AUDIO) {
1965 if (st->codec->codec_id == CODEC_ID_NONE && probe_data[st->index].buf_size > 0) {
1966 codec_identified[st->index] = set_codec_from_probe_data(st, &(probe_data[st->index]), 1);
1967 if (codec_identified[st->index]) {
1968 st->need_parsing = AVSTREAM_PARSE_FULL;
1971 if(!st->codec->bits_per_sample)
1972 st->codec->bits_per_sample= av_get_bits_per_sample(st->codec->codec_id);
1976 av_estimate_timings(ic, old_offset);
1978 for(i=0;i<ic->nb_streams;i++) {
1979 st = ic->streams[i];
1980 if (codec_identified[st->index])
1983 //FIXME this is a mess
1984 if(i!=ic->nb_streams){
1985 av_read_frame_flush(ic);
1986 for(i=0;i<ic->nb_streams;i++) {
1987 st = ic->streams[i];
1988 if (codec_identified[st->index]) {
1989 av_seek_frame(ic, st->index, 0.0, 0);
1991 st->cur_dts= st->first_dts;
1993 url_fseek(&ic->pb, ic->data_offset, SEEK_SET);
1997 /* correct DTS for b frame streams with no timestamps */
1998 for(i=0;i<ic->nb_streams;i++) {
1999 st = ic->streams[i];
2000 if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
2002 ppktl = &ic->packet_buffer;
2004 if(ppkt1->stream_index != i)
2006 if(ppkt1->pkt->dts < 0)
2008 if(ppkt1->pkt->pts != AV_NOPTS_VALUE)
2010 ppkt1->pkt->dts -= delta;
2015 st->cur_dts -= delta;
2021 av_free(duration_error);
2022 for(i=0;i<MAX_STREAMS;i++){
2023 av_freep(&(probe_data[i].buf));
2029 /*******************************************************/
2031 int av_read_play(AVFormatContext *s)
2033 if (!s->iformat->read_play)
2034 return AVERROR(ENOSYS);
2035 return s->iformat->read_play(s);
2038 int av_read_pause(AVFormatContext *s)
2040 if (!s->iformat->read_pause)
2041 return AVERROR(ENOSYS);
2042 return s->iformat->read_pause(s);
2045 void av_close_input_file(AVFormatContext *s)
2047 int i, must_open_file;
2050 /* free previous packet */
2051 if (s->cur_st && s->cur_st->parser)
2052 av_free_packet(&s->cur_pkt);
2054 if (s->iformat->read_close)
2055 s->iformat->read_close(s);
2056 for(i=0;i<s->nb_streams;i++) {
2057 /* free all data in a stream component */
2060 av_parser_close(st->parser);
2062 av_free(st->index_entries);
2063 av_free(st->codec->extradata);
2067 for(i=s->nb_programs-1; i>=0; i--) {
2068 av_freep(&s->programs[i]->provider_name);
2069 av_freep(&s->programs[i]->name);
2070 av_freep(&s->programs[i]->stream_index);
2071 av_freep(&s->programs[i]);
2073 flush_packet_queue(s);
2075 if (s->iformat->flags & AVFMT_NOFILE) {
2078 if (must_open_file) {
2081 av_freep(&s->priv_data);
2085 AVStream *av_new_stream(AVFormatContext *s, int id)
2090 if (s->nb_streams >= MAX_STREAMS)
2093 st = av_mallocz(sizeof(AVStream));
2097 st->codec= avcodec_alloc_context();
2099 /* no default bitrate if decoding */
2100 st->codec->bit_rate = 0;
2102 st->index = s->nb_streams;
2104 st->start_time = AV_NOPTS_VALUE;
2105 st->duration = AV_NOPTS_VALUE;
2106 st->cur_dts = AV_NOPTS_VALUE;
2107 st->first_dts = AV_NOPTS_VALUE;
2109 /* default pts settings is MPEG like */
2110 av_set_pts_info(st, 33, 1, 90000);
2111 st->last_IP_pts = AV_NOPTS_VALUE;
2112 for(i=0; i<MAX_REORDER_DELAY+1; i++)
2113 st->pts_buffer[i]= AV_NOPTS_VALUE;
2115 s->streams[s->nb_streams++] = st;
2119 AVProgram *av_new_program(AVFormatContext *ac, int id)
2121 AVProgram *program=NULL;
2125 av_log(ac, AV_LOG_DEBUG, "new_program: id=0x%04x\n", id);
2128 for(i=0; i<ac->nb_programs; i++)
2129 if(ac->programs[i]->id == id)
2130 program = ac->programs[i];
2133 program = av_mallocz(sizeof(AVProgram));
2136 dynarray_add(&ac->programs, &ac->nb_programs, program);
2137 program->discard = AVDISCARD_NONE;
2144 void av_set_program_name(AVProgram *program, char *provider_name, char *name)
2146 assert(!provider_name == !name);
2148 av_free(program->provider_name);
2149 av_free(program-> name);
2150 program->provider_name = av_strdup(provider_name);
2151 program-> name = av_strdup( name);
2156 /************************************************************/
2157 /* output media file */
2159 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
2163 if (s->oformat->priv_data_size > 0) {
2164 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2166 return AVERROR(ENOMEM);
2168 s->priv_data = NULL;
2170 if (s->oformat->set_parameters) {
2171 ret = s->oformat->set_parameters(s, ap);
2178 int av_write_header(AVFormatContext *s)
2183 // some sanity checks
2184 for(i=0;i<s->nb_streams;i++) {
2187 switch (st->codec->codec_type) {
2188 case CODEC_TYPE_AUDIO:
2189 if(st->codec->sample_rate<=0){
2190 av_log(s, AV_LOG_ERROR, "sample rate not set\n");
2194 case CODEC_TYPE_VIDEO:
2195 if(st->codec->time_base.num<=0 || st->codec->time_base.den<=0){ //FIXME audio too?
2196 av_log(s, AV_LOG_ERROR, "time base not set\n");
2199 if(st->codec->width<=0 || st->codec->height<=0){
2200 av_log(s, AV_LOG_ERROR, "dimensions not set\n");
2206 if(s->oformat->codec_tag){
2207 if(st->codec->codec_tag){
2209 //check that tag + id is in the table
2210 //if neither is in the table -> ok
2211 //if tag is in the table with another id -> FAIL
2212 //if id is in the table with another tag -> FAIL unless strict < ?
2214 st->codec->codec_tag= av_codec_get_tag(s->oformat->codec_tag, st->codec->codec_id);
2218 if (!s->priv_data && s->oformat->priv_data_size > 0) {
2219 s->priv_data = av_mallocz(s->oformat->priv_data_size);
2221 return AVERROR(ENOMEM);
2224 if(s->oformat->write_header){
2225 ret = s->oformat->write_header(s);
2230 /* init PTS generation */
2231 for(i=0;i<s->nb_streams;i++) {
2232 int64_t den = AV_NOPTS_VALUE;
2235 switch (st->codec->codec_type) {
2236 case CODEC_TYPE_AUDIO:
2237 den = (int64_t)st->time_base.num * st->codec->sample_rate;
2239 case CODEC_TYPE_VIDEO:
2240 den = (int64_t)st->time_base.num * st->codec->time_base.den;
2245 if (den != AV_NOPTS_VALUE) {
2247 return AVERROR_INVALIDDATA;
2248 av_frac_init(&st->pts, 0, 0, den);
2254 //FIXME merge with compute_pkt_fields
2255 static int compute_pkt_fields2(AVStream *st, AVPacket *pkt){
2256 int delay = FFMAX(st->codec->has_b_frames, !!st->codec->max_b_frames);
2257 int num, den, frame_size, i;
2259 // 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);
2261 /* if(pkt->pts == AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE)
2264 /* duration field */
2265 if (pkt->duration == 0) {
2266 compute_frame_duration(&num, &den, st, NULL, pkt);
2268 pkt->duration = av_rescale(1, num * (int64_t)st->time_base.den, den * (int64_t)st->time_base.num);
2272 //XXX/FIXME this is a temporary hack until all encoders output pts
2273 if((pkt->pts == 0 || pkt->pts == AV_NOPTS_VALUE) && pkt->dts == AV_NOPTS_VALUE && !delay){
2275 // pkt->pts= st->cur_dts;
2276 pkt->pts= st->pts.val;
2279 //calculate dts from pts
2280 if(pkt->pts != AV_NOPTS_VALUE && pkt->dts == AV_NOPTS_VALUE){
2281 st->pts_buffer[0]= pkt->pts;
2282 for(i=1; i<delay+1 && st->pts_buffer[i] == AV_NOPTS_VALUE; i++)
2283 st->pts_buffer[i]= (i-delay-1) * pkt->duration;
2284 for(i=0; i<delay && st->pts_buffer[i] > st->pts_buffer[i+1]; i++)
2285 FFSWAP(int64_t, st->pts_buffer[i], st->pts_buffer[i+1]);
2287 pkt->dts= st->pts_buffer[0];
2290 if(st->cur_dts && st->cur_dts != AV_NOPTS_VALUE && st->cur_dts >= pkt->dts){
2291 av_log(NULL, AV_LOG_ERROR, "error, non monotone timestamps %"PRId64" >= %"PRId64"\n", st->cur_dts, pkt->dts);
2294 if(pkt->dts != AV_NOPTS_VALUE && pkt->pts != AV_NOPTS_VALUE && pkt->pts < pkt->dts){
2295 av_log(NULL, AV_LOG_ERROR, "error, pts < dts\n");
2299 // av_log(NULL, AV_LOG_DEBUG, "av_write_frame: pts2:%"PRId64" dts2:%"PRId64"\n", pkt->pts, pkt->dts);
2300 st->cur_dts= pkt->dts;
2301 st->pts.val= pkt->dts;
2304 switch (st->codec->codec_type) {
2305 case CODEC_TYPE_AUDIO:
2306 frame_size = get_audio_frame_size(st->codec, pkt->size);
2308 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
2309 but it would be better if we had the real timestamps from the encoder */
2310 if (frame_size >= 0 && (pkt->size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
2311 av_frac_add(&st->pts, (int64_t)st->time_base.den * frame_size);
2314 case CODEC_TYPE_VIDEO:
2315 av_frac_add(&st->pts, (int64_t)st->time_base.den * st->codec->time_base.num);
2323 static void truncate_ts(AVStream *st, AVPacket *pkt){
2324 int64_t pts_mask = (2LL << (st->pts_wrap_bits-1)) - 1;
2327 // pkt->dts= 0; //this happens for low_delay=0 and b frames, FIXME, needs further invstigation about what we should do here
2329 if (pkt->pts != AV_NOPTS_VALUE)
2330 pkt->pts &= pts_mask;
2331 if (pkt->dts != AV_NOPTS_VALUE)
2332 pkt->dts &= pts_mask;
2335 int av_write_frame(AVFormatContext *s, AVPacket *pkt)
2339 ret=compute_pkt_fields2(s->streams[pkt->stream_index], pkt);
2340 if(ret<0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2343 truncate_ts(s->streams[pkt->stream_index], pkt);
2345 ret= s->oformat->write_packet(s, pkt);
2347 ret= url_ferror(&s->pb);
2351 int av_interleave_packet_per_dts(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush){
2352 AVPacketList *pktl, **next_point, *this_pktl;
2354 int streams[MAX_STREAMS];
2357 AVStream *st= s->streams[ pkt->stream_index];
2359 // assert(pkt->destruct != av_destruct_packet); //FIXME
2361 this_pktl = av_mallocz(sizeof(AVPacketList));
2362 this_pktl->pkt= *pkt;
2363 if(pkt->destruct == av_destruct_packet)
2364 pkt->destruct= NULL; // non shared -> must keep original from being freed
2366 av_dup_packet(&this_pktl->pkt); //shared -> must dup
2368 next_point = &s->packet_buffer;
2370 AVStream *st2= s->streams[ (*next_point)->pkt.stream_index];
2371 int64_t left= st2->time_base.num * (int64_t)st ->time_base.den;
2372 int64_t right= st ->time_base.num * (int64_t)st2->time_base.den;
2373 if((*next_point)->pkt.dts * left > pkt->dts * right) //FIXME this can overflow
2375 next_point= &(*next_point)->next;
2377 this_pktl->next= *next_point;
2378 *next_point= this_pktl;
2381 memset(streams, 0, sizeof(streams));
2382 pktl= s->packet_buffer;
2384 //av_log(s, AV_LOG_DEBUG, "show st:%d dts:%"PRId64"\n", pktl->pkt.stream_index, pktl->pkt.dts);
2385 if(streams[ pktl->pkt.stream_index ] == 0)
2387 streams[ pktl->pkt.stream_index ]++;
2391 if(s->nb_streams == stream_count || (flush && stream_count)){
2392 pktl= s->packet_buffer;
2395 s->packet_buffer= pktl->next;
2399 av_init_packet(out);
2405 * Interleaves a AVPacket correctly so it can be muxed.
2406 * @param out the interleaved packet will be output here
2407 * @param in the input packet
2408 * @param flush 1 if no further packets are available as input and all
2409 * remaining packets should be output
2410 * @return 1 if a packet was output, 0 if no packet could be output,
2411 * < 0 if an error occured
2413 static int av_interleave_packet(AVFormatContext *s, AVPacket *out, AVPacket *in, int flush){
2414 if(s->oformat->interleave_packet)
2415 return s->oformat->interleave_packet(s, out, in, flush);
2417 return av_interleave_packet_per_dts(s, out, in, flush);
2420 int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt){
2421 AVStream *st= s->streams[ pkt->stream_index];
2423 //FIXME/XXX/HACK drop zero sized packets
2424 if(st->codec->codec_type == CODEC_TYPE_AUDIO && pkt->size==0)
2427 //av_log(NULL, AV_LOG_DEBUG, "av_interleaved_write_frame %d %"PRId64" %"PRId64"\n", pkt->size, pkt->dts, pkt->pts);
2428 if(compute_pkt_fields2(st, pkt) < 0 && !(s->oformat->flags & AVFMT_NOTIMESTAMPS))
2431 if(pkt->dts == AV_NOPTS_VALUE)
2436 int ret= av_interleave_packet(s, &opkt, pkt, 0);
2437 if(ret<=0) //FIXME cleanup needed for ret<0 ?
2440 truncate_ts(s->streams[opkt.stream_index], &opkt);
2441 ret= s->oformat->write_packet(s, &opkt);
2443 av_free_packet(&opkt);
2448 if(url_ferror(&s->pb))
2449 return url_ferror(&s->pb);
2453 int av_write_trailer(AVFormatContext *s)
2459 ret= av_interleave_packet(s, &pkt, NULL, 1);
2460 if(ret<0) //FIXME cleanup needed for ret<0 ?
2465 truncate_ts(s->streams[pkt.stream_index], &pkt);
2466 ret= s->oformat->write_packet(s, &pkt);
2468 av_free_packet(&pkt);
2472 if(url_ferror(&s->pb))
2476 if(s->oformat->write_trailer)
2477 ret = s->oformat->write_trailer(s);
2480 ret=url_ferror(&s->pb);
2481 for(i=0;i<s->nb_streams;i++)
2482 av_freep(&s->streams[i]->priv_data);
2483 av_freep(&s->priv_data);
2487 void av_program_add_stream_index(AVFormatContext *ac, int progid, unsigned int idx)
2490 AVProgram *program=NULL;
2493 for(i=0; i<ac->nb_programs; i++){
2494 if(ac->programs[i]->id != progid)
2496 program = ac->programs[i];
2497 for(j=0; j<program->nb_stream_indexes; j++)
2498 if(program->stream_index[j] == idx)
2501 tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
2504 program->stream_index = tmp;
2505 program->stream_index[program->nb_stream_indexes++] = idx;
2510 /* "user interface" functions */
2511 static void dump_stream_format(AVFormatContext *ic, int i, int index, char *buf, int is_output)
2513 int flags = (is_output ? ic->oformat->flags : ic->iformat->flags);
2514 AVStream *st = ic->streams[i];
2515 int g = ff_gcd(st->time_base.num, st->time_base.den);
2516 avcodec_string(buf, sizeof(buf), st->codec, is_output);
2517 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d", index, i);
2518 /* the pid is an important information, so we display it */
2519 /* XXX: add a generic system */
2520 if (flags & AVFMT_SHOW_IDS)
2521 av_log(NULL, AV_LOG_INFO, "[0x%x]", st->id);
2522 if (strlen(st->language) > 0)
2523 av_log(NULL, AV_LOG_INFO, "(%s)", st->language);
2524 av_log(NULL, AV_LOG_DEBUG, ", %d/%d", st->time_base.num/g, st->time_base.den/g);
2525 av_log(NULL, AV_LOG_INFO, ": %s", buf);
2526 if(st->codec->codec_type == CODEC_TYPE_VIDEO){
2527 if(st->r_frame_rate.den && st->r_frame_rate.num)
2528 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(r)", av_q2d(st->r_frame_rate));
2529 /* else if(st->time_base.den && st->time_base.num)
2530 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(m)", 1/av_q2d(st->time_base));*/
2532 av_log(NULL, AV_LOG_INFO, ", %5.2f fps(c)", 1/av_q2d(st->codec->time_base));
2534 av_log(NULL, AV_LOG_INFO, "\n");
2537 void dump_format(AVFormatContext *ic,
2545 av_log(NULL, AV_LOG_INFO, "%s #%d, %s, %s '%s':\n",
2546 is_output ? "Output" : "Input",
2548 is_output ? ic->oformat->name : ic->iformat->name,
2549 is_output ? "to" : "from", url);
2551 av_log(NULL, AV_LOG_INFO, " Duration: ");
2552 if (ic->duration != AV_NOPTS_VALUE) {
2553 int hours, mins, secs, us;
2554 secs = ic->duration / AV_TIME_BASE;
2555 us = ic->duration % AV_TIME_BASE;
2560 av_log(NULL, AV_LOG_INFO, "%02d:%02d:%02d.%01d", hours, mins, secs,
2561 (10 * us) / AV_TIME_BASE);
2563 av_log(NULL, AV_LOG_INFO, "N/A");
2565 if (ic->start_time != AV_NOPTS_VALUE) {
2567 av_log(NULL, AV_LOG_INFO, ", start: ");
2568 secs = ic->start_time / AV_TIME_BASE;
2569 us = ic->start_time % AV_TIME_BASE;
2570 av_log(NULL, AV_LOG_INFO, "%d.%06d",
2571 secs, (int)av_rescale(us, 1000000, AV_TIME_BASE));
2573 av_log(NULL, AV_LOG_INFO, ", bitrate: ");
2575 av_log(NULL, AV_LOG_INFO,"%d kb/s", ic->bit_rate / 1000);
2577 av_log(NULL, AV_LOG_INFO, "N/A");
2579 av_log(NULL, AV_LOG_INFO, "\n");
2581 if(ic->nb_programs) {
2583 for(j=0; j<ic->nb_programs; j++) {
2584 av_log(NULL, AV_LOG_INFO, " Program %d", ic->programs[j]->id);
2585 if(ic->programs[j]->name)
2586 av_log(NULL, AV_LOG_INFO, " \"%s\"\n", ic->programs[j]->name);
2587 for(k=0; k<ic->programs[j]->nb_stream_indexes; k++)
2588 dump_stream_format(ic, ic->programs[j]->stream_index[k], index, buf, is_output);
2591 for(i=0;i<ic->nb_streams;i++)
2592 dump_stream_format(ic, i, index, buf, is_output);
2595 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
2597 return av_parse_video_frame_size(width_ptr, height_ptr, str);
2600 int parse_frame_rate(int *frame_rate_num, int *frame_rate_den, const char *arg)
2602 AVRational frame_rate;
2603 int ret = av_parse_video_frame_rate(&frame_rate, arg);
2604 *frame_rate_num= frame_rate.num;
2605 *frame_rate_den= frame_rate.den;
2610 * gets the current time in micro seconds.
2612 int64_t av_gettime(void)
2615 gettimeofday(&tv,NULL);
2616 return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
2619 int64_t parse_date(const char *datestr, int duration)
2625 static const char *date_fmt[] = {
2629 static const char *time_fmt[] = {
2639 time_t now = time(0);
2641 len = strlen(datestr);
2643 lastch = datestr[len - 1];
2646 is_utc = (lastch == 'z' || lastch == 'Z');
2648 memset(&dt, 0, sizeof(dt));
2653 /* parse the year-month-day part */
2654 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
2655 q = small_strptime(p, date_fmt[i], &dt);
2661 /* if the year-month-day part is missing, then take the
2662 * current year-month-day time */
2667 dt = *localtime(&now);
2669 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
2674 if (*p == 'T' || *p == 't' || *p == ' ')
2677 /* parse the hour-minute-second part */
2678 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
2679 q = small_strptime(p, time_fmt[i], &dt);
2685 /* parse datestr as a duration */
2690 /* parse datestr as HH:MM:SS */
2691 q = small_strptime(p, time_fmt[0], &dt);
2693 /* parse datestr as S+ */
2694 dt.tm_sec = strtol(p, (char **)&q, 10);
2696 /* the parsing didn't succeed */
2703 /* Now we have all the fields that we can get */
2709 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
2711 dt.tm_isdst = -1; /* unknown */
2721 /* parse the .m... part */
2725 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
2728 val += n * (*q - '0');
2732 return negative ? -t : t;
2735 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2745 while (*p != '\0' && *p != '=' && *p != '&') {
2746 if ((q - tag) < sizeof(tag) - 1)
2754 while (*p != '&' && *p != '\0') {
2755 if ((q - arg) < arg_size - 1) {
2765 if (!strcmp(tag, tag1))
2774 int av_get_frame_filename(char *buf, int buf_size,
2775 const char *path, int number)
2778 char *q, buf1[20], c;
2779 int nd, len, percentd_found;
2791 while (isdigit(*p)) {
2792 nd = nd * 10 + *p++ - '0';
2795 } while (isdigit(c));
2804 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2806 if ((q - buf + len) > buf_size - 1)
2808 memcpy(q, buf1, len);
2816 if ((q - buf) < buf_size - 1)
2820 if (!percentd_found)
2829 static void hex_dump_internal(void *avcl, FILE *f, int level, uint8_t *buf, int size)
2832 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2834 for(i=0;i<size;i+=16) {
2841 PRINT(" %02x", buf[i+j]);
2846 for(j=0;j<len;j++) {
2848 if (c < ' ' || c > '~')
2857 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2859 hex_dump_internal(NULL, f, 0, buf, size);
2862 void av_hex_dump_log(void *avcl, int level, uint8_t *buf, int size)
2864 hex_dump_internal(avcl, NULL, level, buf, size);
2867 //FIXME needs to know the time_base
2868 static void pkt_dump_internal(void *avcl, FILE *f, int level, AVPacket *pkt, int dump_payload)
2870 #define PRINT(...) do { if (!f) av_log(avcl, level, __VA_ARGS__); else fprintf(f, __VA_ARGS__); } while(0)
2871 PRINT("stream #%d:\n", pkt->stream_index);
2872 PRINT(" keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2873 PRINT(" duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2874 /* DTS is _always_ valid after av_read_frame() */
2876 if (pkt->dts == AV_NOPTS_VALUE)
2879 PRINT("%0.3f", (double)pkt->dts / AV_TIME_BASE);
2880 /* PTS may be not known if B frames are present */
2882 if (pkt->pts == AV_NOPTS_VALUE)
2885 PRINT("%0.3f", (double)pkt->pts / AV_TIME_BASE);
2887 PRINT(" size=%d\n", pkt->size);
2890 av_hex_dump(f, pkt->data, pkt->size);
2893 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2895 pkt_dump_internal(NULL, f, 0, pkt, dump_payload);
2898 void av_pkt_dump_log(void *avcl, int level, AVPacket *pkt, int dump_payload)
2900 pkt_dump_internal(avcl, NULL, level, pkt, dump_payload);
2903 void url_split(char *proto, int proto_size,
2904 char *authorization, int authorization_size,
2905 char *hostname, int hostname_size,
2907 char *path, int path_size,
2910 const char *p, *ls, *at, *col, *brk, *q;
2912 if (port_ptr) *port_ptr = -1;
2913 if (proto_size > 0) proto[0] = 0;
2914 if (authorization_size > 0) authorization[0] = 0;
2915 if (hostname_size > 0) hostname[0] = 0;
2916 if (path_size > 0) path[0] = 0;
2918 /* parse protocol */
2919 if ((p = strchr(url, ':'))) {
2920 av_strlcpy(proto, url, FFMIN(proto_size, p + 1 - url));
2925 /* no protocol means plain filename */
2926 av_strlcpy(path, url, path_size);
2930 /* separate path from hostname */
2931 if ((ls = strchr(p, '/'))) {
2932 if ((q = strchr(ls, '?')))
2933 av_strlcpy(path, ls, FFMIN(path_size, q - ls + 1));
2935 av_strlcpy(path, ls, path_size);
2936 } else if (!(ls = strchr(p, '?')))
2937 ls = &p[strlen(p)]; // XXX
2939 /* the rest is hostname, use that to parse auth/port */
2941 /* authorization (user[:pass]@hostname) */
2942 if ((at = strchr(p, '@')) && at < ls) {
2943 av_strlcpy(authorization, p,
2944 FFMIN(authorization_size, at + 1 - p));
2945 p = at + 1; /* skip '@' */
2948 if (*p == '[' && (brk = strchr(p, ']')) && brk < ls) {
2950 av_strlcpy(hostname, p + 1,
2951 FFMIN(hostname_size, brk - p));
2952 if (brk[1] == ':' && port_ptr)
2953 *port_ptr = atoi(brk + 2);
2954 } else if ((col = strchr(p, ':')) && col < ls) {
2955 av_strlcpy(hostname, p,
2956 FFMIN(col + 1 - p, hostname_size));
2957 if (port_ptr) *port_ptr = atoi(col + 1);
2959 av_strlcpy(hostname, p,
2960 FFMIN(ls + 1 - p, hostname_size));
2964 void av_set_pts_info(AVStream *s, int pts_wrap_bits,
2965 int pts_num, int pts_den)
2967 s->pts_wrap_bits = pts_wrap_bits;
2968 s->time_base.num = pts_num;
2969 s->time_base.den = pts_den;
2972 /* fraction handling */
2975 * f = val + (num / den) + 0.5.
2977 * 'num' is normalized so that it is such as 0 <= num < den.
2979 * @param f fractional number
2980 * @param val integer value
2981 * @param num must be >= 0
2982 * @param den must be >= 1
2984 static void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2997 * Fractionnal addition to f: f = f + (incr / f->den).
2999 * @param f fractional number
3000 * @param incr increment, can be positive or negative
3002 static void av_frac_add(AVFrac *f, int64_t incr)
3006 num = f->num + incr;
3009 f->val += num / den;
3015 } else if (num >= den) {
3016 f->val += num / den;