2 * Various utilities for ffmpeg system
3 * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 AVInputFormat *first_iformat;
25 AVOutputFormat *first_oformat;
26 AVImageFormat *first_image_format;
28 void av_register_input_format(AVInputFormat *format)
32 while (*p != NULL) p = &(*p)->next;
37 void av_register_output_format(AVOutputFormat *format)
41 while (*p != NULL) p = &(*p)->next;
46 int match_ext(const char *filename, const char *extensions)
51 ext = strrchr(filename, '.');
57 while (*p != '\0' && *p != ',')
60 if (!strcasecmp(ext1, ext))
70 AVOutputFormat *guess_format(const char *short_name, const char *filename,
71 const char *mime_type)
73 AVOutputFormat *fmt, *fmt_found;
76 /* specific test for image sequences */
77 if (!short_name && filename &&
78 filename_number_test(filename) >= 0 &&
79 guess_image_format(filename)) {
80 return guess_format("image", NULL, NULL);
83 /* find the proper file type */
89 if (fmt->name && short_name && !strcmp(fmt->name, short_name))
91 if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
93 if (filename && fmt->extensions &&
94 match_ext(filename, fmt->extensions)) {
97 if (score > score_max) {
106 AVOutputFormat *guess_stream_format(const char *short_name, const char *filename,
107 const char *mime_type)
109 AVOutputFormat *fmt = guess_format(short_name, filename, mime_type);
112 AVOutputFormat *stream_fmt;
113 char stream_format_name[64];
115 snprintf(stream_format_name, sizeof(stream_format_name), "%s_stream", fmt->name);
116 stream_fmt = guess_format(stream_format_name, NULL, NULL);
125 AVInputFormat *av_find_input_format(const char *short_name)
128 for(fmt = first_iformat; fmt != NULL; fmt = fmt->next) {
129 if (!strcmp(fmt->name, short_name))
135 /* memory handling */
138 * Default packet destructor
140 static void av_destruct_packet(AVPacket *pkt)
143 pkt->data = NULL; pkt->size = 0;
147 * Allocate the payload of a packet and intialized its fields to default values.
150 * @param size wanted payload size
151 * @return 0 if OK. AVERROR_xxx otherwise.
153 int av_new_packet(AVPacket *pkt, int size)
155 void *data = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE);
157 return AVERROR_NOMEM;
158 memset(data + size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
163 pkt->destruct = av_destruct_packet;
167 /* This is a hack - the packet memory allocation stuff is broken. The
168 packet is allocated if it was not really allocated */
169 int av_dup_packet(AVPacket *pkt)
171 if (pkt->destruct != av_destruct_packet) {
173 /* we duplicate the packet and don't forget to put the padding
175 data = av_malloc(pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);
177 return AVERROR_NOMEM;
179 memcpy(data, pkt->data, pkt->size);
180 memset(data + pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
182 pkt->destruct = av_destruct_packet;
189 int fifo_init(FifoBuffer *f, int size)
191 f->buffer = av_malloc(size);
194 f->end = f->buffer + size;
195 f->wptr = f->rptr = f->buffer;
199 void fifo_free(FifoBuffer *f)
204 int fifo_size(FifoBuffer *f, uint8_t *rptr)
208 if (f->wptr >= rptr) {
209 size = f->wptr - rptr;
211 size = (f->end - rptr) + (f->wptr - f->buffer);
216 /* get data from the fifo (return -1 if not enough data) */
217 int fifo_read(FifoBuffer *f, uint8_t *buf, int buf_size, uint8_t **rptr_ptr)
219 uint8_t *rptr = *rptr_ptr;
222 if (f->wptr >= rptr) {
223 size = f->wptr - rptr;
225 size = (f->end - rptr) + (f->wptr - f->buffer);
230 while (buf_size > 0) {
234 memcpy(buf, rptr, len);
245 void fifo_write(FifoBuffer *f, uint8_t *buf, int size, uint8_t **wptr_ptr)
254 memcpy(wptr, buf, len);
264 int filename_number_test(const char *filename)
267 return get_frame_filename(buf, sizeof(buf), filename, 1);
270 /* guess file format */
271 AVInputFormat *av_probe_input_format(AVProbeData *pd, int is_opened)
273 AVInputFormat *fmt1, *fmt;
274 int score, score_max;
278 for(fmt1 = first_iformat; fmt1 != NULL; fmt1 = fmt1->next) {
279 if (!is_opened && !(fmt1->flags & AVFMT_NOFILE))
282 if (fmt1->read_probe) {
283 score = fmt1->read_probe(pd);
284 } else if (fmt1->extensions) {
285 if (match_ext(pd->filename, fmt1->extensions)) {
289 if (score > score_max) {
297 /************************************************************/
298 /* input media file */
301 * open a media file from an IO stream. 'fmt' must be specified.
304 static const char* format_to_name(void* ptr)
306 AVFormatContext* fc = (AVFormatContext*) ptr;
307 if(fc->iformat) return fc->iformat->name;
308 else if(fc->oformat) return fc->oformat->name;
312 static const AVClass av_format_context_class = { "AVFormatContext", format_to_name };
314 AVFormatContext *av_alloc_format_context(void)
317 ic = av_mallocz(sizeof(AVFormatContext));
319 ic->av_class = &av_format_context_class;
323 int av_open_input_stream(AVFormatContext **ic_ptr,
324 ByteIOContext *pb, const char *filename,
325 AVInputFormat *fmt, AVFormatParameters *ap)
330 ic = av_alloc_format_context();
338 ic->duration = AV_NOPTS_VALUE;
339 ic->start_time = AV_NOPTS_VALUE;
340 pstrcpy(ic->filename, sizeof(ic->filename), filename);
342 /* allocate private data */
343 if (fmt->priv_data_size > 0) {
344 ic->priv_data = av_mallocz(fmt->priv_data_size);
345 if (!ic->priv_data) {
350 ic->priv_data = NULL;
353 /* default pts settings is MPEG like */
354 av_set_pts_info(ic, 33, 1, 90000);
355 ic->last_pkt_pts = AV_NOPTS_VALUE;
356 ic->last_pkt_dts = AV_NOPTS_VALUE;
357 ic->last_pkt_stream_pts = AV_NOPTS_VALUE;
358 ic->last_pkt_stream_dts = AV_NOPTS_VALUE;
360 err = ic->iformat->read_header(ic, ap);
365 ic->data_offset = url_ftell(&ic->pb);
371 av_freep(&ic->priv_data);
378 #define PROBE_BUF_SIZE 2048
381 * Open a media file as input. The codec are not opened. Only the file
382 * header (if present) is read.
384 * @param ic_ptr the opened media file handle is put here
385 * @param filename filename to open.
386 * @param fmt if non NULL, force the file format to use
387 * @param buf_size optional buffer size (zero if default is OK)
388 * @param ap additionnal parameters needed when opening the file (NULL if default)
389 * @return 0 if OK. AVERROR_xxx otherwise.
391 int av_open_input_file(AVFormatContext **ic_ptr, const char *filename,
394 AVFormatParameters *ap)
396 int err, must_open_file, file_opened;
397 uint8_t buf[PROBE_BUF_SIZE];
398 AVProbeData probe_data, *pd = &probe_data;
399 ByteIOContext pb1, *pb = &pb1;
404 pd->filename = filename;
409 /* guess format if no file can be opened */
410 fmt = av_probe_input_format(pd, 0);
413 /* do not open file if the format does not need it. XXX: specific
414 hack needed to handle RTSP/TCP */
416 if (fmt && (fmt->flags & AVFMT_NOFILE)) {
420 if (!fmt || must_open_file) {
421 /* if no file needed do not try to open one */
422 if (url_fopen(pb, filename, URL_RDONLY) < 0) {
428 url_setbufsize(pb, buf_size);
431 /* read probe data */
432 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
433 url_fseek(pb, 0, SEEK_SET);
437 /* guess file format */
439 fmt = av_probe_input_format(pd, 1);
442 /* if still no format found, error */
448 /* XXX: suppress this hack for redirectors */
449 #ifdef CONFIG_NETWORK
450 if (fmt == &redir_demux) {
451 err = redir_open(ic_ptr, pb);
457 /* check filename in case of an image number is expected */
458 if (fmt->flags & AVFMT_NEEDNUMBER) {
459 if (filename_number_test(filename) < 0) {
460 err = AVERROR_NUMEXPECTED;
464 err = av_open_input_stream(ic_ptr, pb, filename, fmt, ap);
476 /*******************************************************/
479 * Read a transport packet from a media file. This function is
480 * absolete and should never be used. Use av_read_frame() instead.
482 * @param s media file handle
483 * @param pkt is filled
484 * @return 0 if OK. AVERROR_xxx if error.
486 int av_read_packet(AVFormatContext *s, AVPacket *pkt)
488 return s->iformat->read_packet(s, pkt);
491 /**********************************************************/
493 /* convert the packet time stamp units and handle wrapping. The
494 wrapping is handled by considering the next PTS/DTS as a delta to
495 the previous value. We handle the delta as a fraction to avoid any
497 static inline int64_t convert_timestamp_units(AVFormatContext *s,
498 int64_t *plast_pkt_pts,
499 int *plast_pkt_pts_frac,
500 int64_t *plast_pkt_stream_pts,
507 if (pts != AV_NOPTS_VALUE) {
509 if (*plast_pkt_stream_pts != AV_NOPTS_VALUE) {
510 shift = 64 - s->pts_wrap_bits;
511 delta_pts = ((stream_pts - *plast_pkt_stream_pts) << shift) >> shift;
512 /* XXX: overflow possible but very unlikely as it is a delta */
513 delta_pts = delta_pts * AV_TIME_BASE * s->pts_num;
514 pts = *plast_pkt_pts + (delta_pts / s->pts_den);
515 pts_frac = *plast_pkt_pts_frac + (delta_pts % s->pts_den);
516 if (pts_frac >= s->pts_den) {
517 pts_frac -= s->pts_den;
521 /* no previous pts, so no wrapping possible */
522 pts = (int64_t)(((double)stream_pts * AV_TIME_BASE * s->pts_num) /
526 *plast_pkt_stream_pts = stream_pts;
527 *plast_pkt_pts = pts;
528 *plast_pkt_pts_frac = pts_frac;
533 /* get the number of samples of an audio frame. Return (-1) if error */
534 static int get_audio_frame_size(AVCodecContext *enc, int size)
538 if (enc->frame_size <= 1) {
539 /* specific hack for pcm codecs because no frame size is
541 switch(enc->codec_id) {
542 case CODEC_ID_PCM_S16LE:
543 case CODEC_ID_PCM_S16BE:
544 case CODEC_ID_PCM_U16LE:
545 case CODEC_ID_PCM_U16BE:
546 if (enc->channels == 0)
548 frame_size = size / (2 * enc->channels);
550 case CODEC_ID_PCM_S8:
551 case CODEC_ID_PCM_U8:
552 case CODEC_ID_PCM_MULAW:
553 case CODEC_ID_PCM_ALAW:
554 if (enc->channels == 0)
556 frame_size = size / (enc->channels);
559 /* used for example by ADPCM codecs */
560 if (enc->bit_rate == 0)
562 frame_size = (size * 8 * enc->sample_rate) / enc->bit_rate;
566 frame_size = enc->frame_size;
572 /* return the frame duration in seconds, return 0 if not available */
573 static void compute_frame_duration(int *pnum, int *pden,
574 AVFormatContext *s, AVStream *st,
575 AVCodecParserContext *pc, AVPacket *pkt)
581 switch(st->codec.codec_type) {
582 case CODEC_TYPE_VIDEO:
583 *pnum = st->codec.frame_rate_base;
584 *pden = st->codec.frame_rate;
585 if (pc && pc->repeat_pict) {
587 *pnum = (*pnum) * (2 + pc->repeat_pict);
590 case CODEC_TYPE_AUDIO:
591 frame_size = get_audio_frame_size(&st->codec, pkt->size);
595 *pden = st->codec.sample_rate;
602 static void compute_pkt_fields(AVFormatContext *s, AVStream *st,
603 AVCodecParserContext *pc, AVPacket *pkt)
605 int num, den, presentation_delayed;
607 if (pkt->duration == 0) {
608 compute_frame_duration(&num, &den, s, st, pc, pkt);
610 pkt->duration = (num * (int64_t)AV_TIME_BASE) / den;
614 /* do we have a video B frame ? */
615 presentation_delayed = 0;
616 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
617 /* XXX: need has_b_frame, but cannot get it if the codec is
619 if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
620 st->codec.codec_id == CODEC_ID_MPEG2VIDEO ||
621 st->codec.codec_id == CODEC_ID_MPEG4 ||
622 st->codec.codec_id == CODEC_ID_H264) &&
623 pc && pc->pict_type != FF_B_TYPE)
624 presentation_delayed = 1;
627 /* interpolate PTS and DTS if they are not present */
628 if (presentation_delayed) {
629 /* DTS = decompression time stamp */
630 /* PTS = presentation time stamp */
631 if (pkt->dts == AV_NOPTS_VALUE) {
632 pkt->dts = st->cur_dts;
634 st->cur_dts = pkt->dts;
636 /* this is tricky: the dts must be incremented by the duration
637 of the frame we are displaying, i.e. the last I or P frame */
638 if (st->last_IP_duration == 0)
639 st->cur_dts += pkt->duration;
641 st->cur_dts += st->last_IP_duration;
642 st->last_IP_duration = pkt->duration;
643 /* cannot compute PTS if not present (we can compute it only
644 by knowing the futur */
646 /* presentation is not delayed : PTS and DTS are the same */
647 if (pkt->pts == AV_NOPTS_VALUE) {
648 if (pkt->dts == AV_NOPTS_VALUE) {
649 pkt->pts = st->cur_dts;
650 pkt->dts = st->cur_dts;
653 st->cur_dts = pkt->dts;
657 st->cur_dts = pkt->pts;
660 st->cur_dts += pkt->duration;
666 /* key frame computation */
667 switch(st->codec.codec_type) {
668 case CODEC_TYPE_VIDEO:
669 if (pc->pict_type == FF_I_TYPE)
670 pkt->flags |= PKT_FLAG_KEY;
672 case CODEC_TYPE_AUDIO:
673 pkt->flags |= PKT_FLAG_KEY;
682 static void av_destruct_packet_nofree(AVPacket *pkt)
684 pkt->data = NULL; pkt->size = 0;
687 static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
693 /* select current input stream component */
697 /* no parsing needed: we just output the packet as is */
698 /* raw data support */
700 compute_pkt_fields(s, st, NULL, pkt);
703 } else if (s->cur_len > 0) {
704 len = av_parser_parse(st->parser, &st->codec, &pkt->data, &pkt->size,
705 s->cur_ptr, s->cur_len,
706 s->cur_pkt.pts, s->cur_pkt.dts);
707 s->cur_pkt.pts = AV_NOPTS_VALUE;
708 s->cur_pkt.dts = AV_NOPTS_VALUE;
709 /* increment read pointer */
713 /* return packet if any */
717 pkt->stream_index = st->index;
718 pkt->pts = st->parser->pts;
719 pkt->dts = st->parser->dts;
720 pkt->destruct = av_destruct_packet_nofree;
721 compute_pkt_fields(s, st, st->parser, pkt);
726 av_free_packet(&s->cur_pkt);
730 /* read next packet */
731 ret = av_read_packet(s, &s->cur_pkt);
735 /* return the last frames, if any */
736 for(i = 0; i < s->nb_streams; i++) {
739 av_parser_parse(st->parser, &st->codec,
740 &pkt->data, &pkt->size,
742 AV_NOPTS_VALUE, AV_NOPTS_VALUE);
747 /* no more packets: really terminates parsing */
751 /* convert the packet time stamp units and handle wrapping */
752 s->cur_pkt.pts = convert_timestamp_units(s,
753 &s->last_pkt_pts, &s->last_pkt_pts_frac,
754 &s->last_pkt_stream_pts,
756 s->cur_pkt.dts = convert_timestamp_units(s,
757 &s->last_pkt_dts, &s->last_pkt_dts_frac,
758 &s->last_pkt_stream_dts,
761 if (s->cur_pkt.stream_index == 0) {
762 if (s->cur_pkt.pts != AV_NOPTS_VALUE)
763 printf("PACKET pts=%0.3f\n",
764 (double)s->cur_pkt.pts / AV_TIME_BASE);
765 if (s->cur_pkt.dts != AV_NOPTS_VALUE)
766 printf("PACKET dts=%0.3f\n",
767 (double)s->cur_pkt.dts / AV_TIME_BASE);
772 if (s->cur_pkt.duration != 0) {
773 s->cur_pkt.duration = ((int64_t)s->cur_pkt.duration * AV_TIME_BASE * s->pts_num) /
777 st = s->streams[s->cur_pkt.stream_index];
779 s->cur_ptr = s->cur_pkt.data;
780 s->cur_len = s->cur_pkt.size;
781 if (st->need_parsing && !st->parser) {
782 st->parser = av_parser_init(st->codec.codec_id);
784 /* no parser available : just output the raw packets */
785 st->need_parsing = 0;
793 * Return the next frame of a stream. The returned packet is valid
794 * until the next av_read_frame() or until av_close_input_file() and
795 * must be freed with av_free_packet. For video, the packet contains
796 * exactly one frame. For audio, it contains an integer number of
797 * frames if each frame has a known fixed size (e.g. PCM or ADPCM
798 * data). If the audio frames have a variable size (e.g. MPEG audio),
799 * then it contains one frame.
801 * pkt->pts, pkt->dts and pkt->duration are always set to correct
802 * values in AV_TIME_BASE unit (and guessed if the format cannot
803 * provided them). pkt->pts can be AV_NOPTS_VALUE if the video format
804 * has B frames, so it is better to rely on pkt->dts if you do not
805 * decompress the payload.
807 * Return 0 if OK, < 0 if error or end of file.
809 int av_read_frame(AVFormatContext *s, AVPacket *pkt)
813 pktl = s->packet_buffer;
815 /* read packet from packet buffer, if there is data */
817 s->packet_buffer = pktl->next;
821 return av_read_frame_internal(s, pkt);
825 /* XXX: suppress the packet queue */
826 static void flush_packet_queue(AVFormatContext *s)
831 pktl = s->packet_buffer;
834 s->packet_buffer = pktl->next;
835 av_free_packet(&pktl->pkt);
840 /*******************************************************/
843 int av_find_default_stream_index(AVFormatContext *s)
848 if (s->nb_streams <= 0)
850 for(i = 0; i < s->nb_streams; i++) {
852 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
859 /* flush the frame reader */
860 static void av_read_frame_flush(AVFormatContext *s)
865 flush_packet_queue(s);
867 /* free previous packet */
869 if (s->cur_st->parser)
870 av_free_packet(&s->cur_pkt);
877 /* for each stream, reset read state */
878 for(i = 0; i < s->nb_streams; i++) {
882 av_parser_close(st->parser);
885 st->cur_dts = 0; /* we set the current DTS to an unspecified origin */
889 /* add a index entry into a sorted list updateing if it is already there */
890 int av_add_index_entry(AVStream *st,
891 int64_t pos, int64_t timestamp, int distance, int flags)
893 AVIndexEntry *entries, *ie;
896 entries = av_fast_realloc(st->index_entries,
897 &st->index_entries_allocated_size,
898 (st->nb_index_entries + 1) *
899 sizeof(AVIndexEntry));
900 st->index_entries= entries;
902 if(st->nb_index_entries){
903 index= av_index_search_timestamp(st, timestamp);
906 if(ie->timestamp != timestamp){
907 if(ie->timestamp < timestamp){
908 index++; //index points to next instead of previous entry, maybe nonexistant
909 ie= &st->index_entries[index];
913 if(index != st->nb_index_entries){
914 assert(index < st->nb_index_entries);
915 memmove(entries + index + 1, entries + index, sizeof(AVIndexEntry)*(st->nb_index_entries - index));
917 st->nb_index_entries++;
919 if(ie->pos == pos && distance < ie->min_distance) //dont reduce the distance
920 distance= ie->min_distance;
923 index= st->nb_index_entries++;
928 ie->timestamp = timestamp;
929 ie->min_distance= distance;
935 /* build an index for raw streams using a parser */
936 static void av_build_index_raw(AVFormatContext *s)
938 AVPacket pkt1, *pkt = &pkt1;
943 av_read_frame_flush(s);
944 url_fseek(&s->pb, s->data_offset, SEEK_SET);
947 ret = av_read_frame(s, pkt);
950 if (pkt->stream_index == 0 && st->parser &&
951 (pkt->flags & PKT_FLAG_KEY)) {
952 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
953 0, AVINDEX_KEYFRAME);
959 /* return TRUE if we deal with a raw stream (raw codec data and
961 static int is_raw_stream(AVFormatContext *s)
965 if (s->nb_streams != 1)
968 if (!st->need_parsing)
973 /* return the largest index entry whose timestamp is <=
975 int av_index_search_timestamp(AVStream *st, int wanted_timestamp)
977 AVIndexEntry *entries= st->index_entries;
978 int nb_entries= st->nb_index_entries;
989 m = (a + b + 1) >> 1;
990 timestamp = entries[m].timestamp;
991 if (timestamp > wanted_timestamp) {
1000 static int av_seek_frame_generic(AVFormatContext *s,
1001 int stream_index, int64_t timestamp)
1007 if (!s->index_built) {
1008 if (is_raw_stream(s)) {
1009 av_build_index_raw(s);
1016 if (stream_index < 0)
1018 st = s->streams[stream_index];
1019 index = av_index_search_timestamp(st, timestamp);
1023 /* now we have found the index, we can seek */
1024 ie = &st->index_entries[index];
1025 av_read_frame_flush(s);
1026 url_fseek(&s->pb, ie->pos, SEEK_SET);
1027 st->cur_dts = ie->timestamp;
1032 * Seek to the key frame just before the frame at timestamp
1033 * 'timestamp' in 'stream_index'. If stream_index is (-1), a default
1034 * stream is selected
1036 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp)
1040 av_read_frame_flush(s);
1042 /* first, we try the format specific seek */
1043 if (s->iformat->read_seek)
1044 ret = s->iformat->read_seek(s, stream_index, timestamp);
1051 return av_seek_frame_generic(s, stream_index, timestamp);
1054 /*******************************************************/
1056 /* return TRUE if the stream has accurate timings for at least one component */
1057 static int av_has_timings(AVFormatContext *ic)
1062 for(i = 0;i < ic->nb_streams; i++) {
1063 st = ic->streams[i];
1064 if (st->start_time != AV_NOPTS_VALUE &&
1065 st->duration != AV_NOPTS_VALUE)
1071 /* estimate the stream timings from the one of each components. Also
1072 compute the global bitrate if possible */
1073 static void av_update_stream_timings(AVFormatContext *ic)
1075 int64_t start_time, end_time, end_time1;
1079 start_time = MAXINT64;
1080 end_time = MININT64;
1081 for(i = 0;i < ic->nb_streams; i++) {
1082 st = ic->streams[i];
1083 if (st->start_time != AV_NOPTS_VALUE) {
1084 if (st->start_time < start_time)
1085 start_time = st->start_time;
1086 if (st->duration != AV_NOPTS_VALUE) {
1087 end_time1 = st->start_time + st->duration;
1088 if (end_time1 > end_time)
1089 end_time = end_time1;
1093 if (start_time != MAXINT64) {
1094 ic->start_time = start_time;
1095 if (end_time != MAXINT64) {
1096 ic->duration = end_time - start_time;
1097 if (ic->file_size > 0) {
1098 /* compute the bit rate */
1099 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1100 (double)ic->duration;
1107 static void fill_all_stream_timings(AVFormatContext *ic)
1112 av_update_stream_timings(ic);
1113 for(i = 0;i < ic->nb_streams; i++) {
1114 st = ic->streams[i];
1115 if (st->start_time == AV_NOPTS_VALUE) {
1116 st->start_time = ic->start_time;
1117 st->duration = ic->duration;
1122 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1124 int64_t filesize, duration;
1128 /* if bit_rate is already set, we believe it */
1129 if (ic->bit_rate == 0) {
1131 for(i=0;i<ic->nb_streams;i++) {
1132 st = ic->streams[i];
1133 bit_rate += st->codec.bit_rate;
1135 ic->bit_rate = bit_rate;
1138 /* if duration is already set, we believe it */
1139 if (ic->duration == AV_NOPTS_VALUE &&
1140 ic->bit_rate != 0 &&
1141 ic->file_size != 0) {
1142 filesize = ic->file_size;
1144 duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1145 for(i = 0; i < ic->nb_streams; i++) {
1146 st = ic->streams[i];
1147 if (st->start_time == AV_NOPTS_VALUE ||
1148 st->duration == AV_NOPTS_VALUE) {
1150 st->duration = duration;
1157 #define DURATION_MAX_READ_SIZE 250000
1159 /* only usable for MPEG-PS streams */
1160 static void av_estimate_timings_from_pts(AVFormatContext *ic)
1162 AVPacket pkt1, *pkt = &pkt1;
1164 int read_size, i, ret;
1165 int64_t start_time, end_time, end_time1;
1166 int64_t filesize, offset, duration;
1168 /* free previous packet */
1169 if (ic->cur_st && ic->cur_st->parser)
1170 av_free_packet(&ic->cur_pkt);
1173 /* flush packet queue */
1174 flush_packet_queue(ic);
1177 /* we read the first packets to get the first PTS (not fully
1178 accurate, but it is enough now) */
1179 url_fseek(&ic->pb, 0, SEEK_SET);
1182 if (read_size >= DURATION_MAX_READ_SIZE)
1184 /* if all info is available, we can stop */
1185 for(i = 0;i < ic->nb_streams; i++) {
1186 st = ic->streams[i];
1187 if (st->start_time == AV_NOPTS_VALUE)
1190 if (i == ic->nb_streams)
1193 ret = av_read_packet(ic, pkt);
1196 read_size += pkt->size;
1197 st = ic->streams[pkt->stream_index];
1198 if (pkt->pts != AV_NOPTS_VALUE) {
1199 if (st->start_time == AV_NOPTS_VALUE)
1200 st->start_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
1202 av_free_packet(pkt);
1205 /* we compute the minimum start_time and use it as default */
1206 start_time = MAXINT64;
1207 for(i = 0; i < ic->nb_streams; i++) {
1208 st = ic->streams[i];
1209 if (st->start_time != AV_NOPTS_VALUE &&
1210 st->start_time < start_time)
1211 start_time = st->start_time;
1213 if (start_time != MAXINT64)
1214 ic->start_time = start_time;
1216 /* estimate the end time (duration) */
1217 /* XXX: may need to support wrapping */
1218 filesize = ic->file_size;
1219 offset = filesize - DURATION_MAX_READ_SIZE;
1223 url_fseek(&ic->pb, offset, SEEK_SET);
1226 if (read_size >= DURATION_MAX_READ_SIZE)
1228 /* if all info is available, we can stop */
1229 for(i = 0;i < ic->nb_streams; i++) {
1230 st = ic->streams[i];
1231 if (st->duration == AV_NOPTS_VALUE)
1234 if (i == ic->nb_streams)
1237 ret = av_read_packet(ic, pkt);
1240 read_size += pkt->size;
1241 st = ic->streams[pkt->stream_index];
1242 if (pkt->pts != AV_NOPTS_VALUE) {
1243 end_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
1244 duration = end_time - st->start_time;
1246 if (st->duration == AV_NOPTS_VALUE ||
1247 st->duration < duration)
1248 st->duration = duration;
1251 av_free_packet(pkt);
1254 /* estimate total duration */
1255 end_time = MININT64;
1256 for(i = 0;i < ic->nb_streams; i++) {
1257 st = ic->streams[i];
1258 if (st->duration != AV_NOPTS_VALUE) {
1259 end_time1 = st->start_time + st->duration;
1260 if (end_time1 > end_time)
1261 end_time = end_time1;
1265 /* update start_time (new stream may have been created, so we do
1267 if (ic->start_time != AV_NOPTS_VALUE) {
1268 for(i = 0; i < ic->nb_streams; i++) {
1269 st = ic->streams[i];
1270 if (st->start_time == AV_NOPTS_VALUE)
1271 st->start_time = ic->start_time;
1275 if (end_time != MININT64) {
1276 /* put dummy values for duration if needed */
1277 for(i = 0;i < ic->nb_streams; i++) {
1278 st = ic->streams[i];
1279 if (st->duration == AV_NOPTS_VALUE &&
1280 st->start_time != AV_NOPTS_VALUE)
1281 st->duration = end_time - st->start_time;
1283 ic->duration = end_time - ic->start_time;
1286 url_fseek(&ic->pb, 0, SEEK_SET);
1289 static void av_estimate_timings(AVFormatContext *ic)
1294 /* get the file size, if possible */
1295 if (ic->iformat->flags & AVFMT_NOFILE) {
1298 h = url_fileno(&ic->pb);
1299 file_size = url_filesize(h);
1303 ic->file_size = file_size;
1305 if (ic->iformat == &mpegps_demux) {
1306 /* get accurate estimate from the PTSes */
1307 av_estimate_timings_from_pts(ic);
1308 } else if (av_has_timings(ic)) {
1309 /* at least one components has timings - we use them for all
1311 fill_all_stream_timings(ic);
1313 /* less precise: use bit rate info */
1314 av_estimate_timings_from_bit_rate(ic);
1316 av_update_stream_timings(ic);
1322 for(i = 0;i < ic->nb_streams; i++) {
1323 st = ic->streams[i];
1324 printf("%d: start_time: %0.3f duration: %0.3f\n",
1325 i, (double)st->start_time / AV_TIME_BASE,
1326 (double)st->duration / AV_TIME_BASE);
1328 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1329 (double)ic->start_time / AV_TIME_BASE,
1330 (double)ic->duration / AV_TIME_BASE,
1331 ic->bit_rate / 1000);
1336 static int has_codec_parameters(AVCodecContext *enc)
1339 switch(enc->codec_type) {
1340 case CODEC_TYPE_AUDIO:
1341 val = enc->sample_rate;
1343 case CODEC_TYPE_VIDEO:
1353 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1357 int got_picture, ret;
1360 codec = avcodec_find_decoder(st->codec.codec_id);
1363 ret = avcodec_open(&st->codec, codec);
1366 switch(st->codec.codec_type) {
1367 case CODEC_TYPE_VIDEO:
1368 ret = avcodec_decode_video(&st->codec, &picture,
1369 &got_picture, (uint8_t *)data, size);
1371 case CODEC_TYPE_AUDIO:
1372 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1375 ret = avcodec_decode_audio(&st->codec, samples,
1376 &got_picture, (uint8_t *)data, size);
1383 avcodec_close(&st->codec);
1387 /* absolute maximum size we read until we abort */
1388 #define MAX_READ_SIZE 5000000
1390 /* maximum duration until we stop analysing the stream */
1391 #define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 1.0))
1394 * Read the beginning of a media file to get stream information. This
1395 * is useful for file formats with no headers such as MPEG. This
1396 * function also compute the real frame rate in case of mpeg2 repeat
1399 * @param ic media file handle
1400 * @return >=0 if OK. AVERROR_xxx if error.
1402 int av_find_stream_info(AVFormatContext *ic)
1404 int i, count, ret, read_size;
1406 AVPacket pkt1, *pkt;
1407 AVPacketList *pktl=NULL, **ppktl;
1411 ppktl = &ic->packet_buffer;
1413 /* check if one codec still needs to be handled */
1414 for(i=0;i<ic->nb_streams;i++) {
1415 st = ic->streams[i];
1416 if (!has_codec_parameters(&st->codec))
1419 if (i == ic->nb_streams) {
1420 /* NOTE: if the format has no header, then we need to read
1421 some packets to get most of the streams, so we cannot
1423 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1424 /* if we found the info for all the codecs, we can stop */
1429 /* we did not get all the codec info, but we read too much data */
1430 if (read_size >= MAX_READ_SIZE) {
1436 /* NOTE: a new stream can be added there if no header in file
1437 (AVFMTCTX_NOHEADER) */
1438 ret = av_read_frame_internal(ic, &pkt1);
1441 ret = -1; /* we could not have all the codec parameters before EOF */
1442 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1443 i == ic->nb_streams)
1448 pktl = av_mallocz(sizeof(AVPacketList));
1450 ret = AVERROR_NOMEM;
1454 /* add the packet in the buffered packet list */
1456 ppktl = &pktl->next;
1461 /* duplicate the packet */
1462 if (av_dup_packet(pkt) < 0) {
1463 ret = AVERROR_NOMEM;
1467 read_size += pkt->size;
1469 st = ic->streams[pkt->stream_index];
1470 st->codec_info_duration += pkt->duration;
1471 if (pkt->duration != 0)
1472 st->codec_info_nb_frames++;
1474 /* if still no information, we try to open the codec and to
1475 decompress the frame. We try to avoid that in most cases as
1476 it takes longer and uses more memory. For MPEG4, we need to
1477 decompress for Quicktime. */
1478 if (!has_codec_parameters(&st->codec) &&
1479 (st->codec.codec_id == CODEC_ID_FLV1 ||
1480 st->codec.codec_id == CODEC_ID_H264 ||
1481 st->codec.codec_id == CODEC_ID_H263 ||
1482 st->codec.codec_id == CODEC_ID_VORBIS ||
1483 (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1484 try_decode_frame(st, pkt->data, pkt->size);
1486 if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1492 /* set real frame rate info */
1493 for(i=0;i<ic->nb_streams;i++) {
1494 st = ic->streams[i];
1495 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1496 /* compute the real frame rate for telecine */
1497 if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1498 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1499 st->codec.sub_id == 2) {
1500 if (st->codec_info_nb_frames >= 20) {
1501 float coded_frame_rate, est_frame_rate;
1502 est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
1503 (double)st->codec_info_duration ;
1504 coded_frame_rate = (double)st->codec.frame_rate /
1505 (double)st->codec.frame_rate_base;
1507 printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
1508 coded_frame_rate, est_frame_rate);
1510 /* if we detect that it could be a telecine, we
1511 signal it. It would be better to do it at a
1512 higher level as it can change in a film */
1513 if (coded_frame_rate >= 24.97 &&
1514 (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1515 st->r_frame_rate = 24024;
1516 st->r_frame_rate_base = 1001;
1520 /* if no real frame rate, use the codec one */
1521 if (!st->r_frame_rate){
1522 st->r_frame_rate = st->codec.frame_rate;
1523 st->r_frame_rate_base = st->codec.frame_rate_base;
1528 av_estimate_timings(ic);
1532 /*******************************************************/
1535 * start playing a network based stream (e.g. RTSP stream) at the
1538 int av_read_play(AVFormatContext *s)
1540 if (!s->iformat->read_play)
1541 return AVERROR_NOTSUPP;
1542 return s->iformat->read_play(s);
1546 * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1549 int av_read_pause(AVFormatContext *s)
1551 if (!s->iformat->read_pause)
1552 return AVERROR_NOTSUPP;
1553 return s->iformat->read_pause(s);
1557 * Close a media file (but not its codecs)
1559 * @param s media file handle
1561 void av_close_input_file(AVFormatContext *s)
1563 int i, must_open_file;
1566 /* free previous packet */
1567 if (s->cur_st && s->cur_st->parser)
1568 av_free_packet(&s->cur_pkt);
1570 if (s->iformat->read_close)
1571 s->iformat->read_close(s);
1572 for(i=0;i<s->nb_streams;i++) {
1573 /* free all data in a stream component */
1576 av_parser_close(st->parser);
1578 av_free(st->index_entries);
1581 flush_packet_queue(s);
1583 if (s->iformat->flags & AVFMT_NOFILE) {
1586 if (must_open_file) {
1589 av_freep(&s->priv_data);
1594 * Add a new stream to a media file. Can only be called in the
1595 * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1596 * format context, then new streams can be added in read_packet too.
1599 * @param s media file handle
1600 * @param id file format dependent stream id
1602 AVStream *av_new_stream(AVFormatContext *s, int id)
1606 if (s->nb_streams >= MAX_STREAMS)
1609 st = av_mallocz(sizeof(AVStream));
1612 avcodec_get_context_defaults(&st->codec);
1614 /* no default bitrate if decoding */
1615 st->codec.bit_rate = 0;
1617 st->index = s->nb_streams;
1619 st->start_time = AV_NOPTS_VALUE;
1620 st->duration = AV_NOPTS_VALUE;
1621 s->streams[s->nb_streams++] = st;
1625 /************************************************************/
1626 /* output media file */
1628 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1632 if (s->oformat->priv_data_size > 0) {
1633 s->priv_data = av_mallocz(s->oformat->priv_data_size);
1635 return AVERROR_NOMEM;
1637 s->priv_data = NULL;
1639 if (s->oformat->set_parameters) {
1640 ret = s->oformat->set_parameters(s, ap);
1648 * allocate the stream private data and write the stream header to an
1651 * @param s media file handle
1652 * @return 0 if OK. AVERROR_xxx if error.
1654 int av_write_header(AVFormatContext *s)
1659 /* default pts settings is MPEG like */
1660 av_set_pts_info(s, 33, 1, 90000);
1661 ret = s->oformat->write_header(s);
1665 /* init PTS generation */
1666 for(i=0;i<s->nb_streams;i++) {
1669 switch (st->codec.codec_type) {
1670 case CODEC_TYPE_AUDIO:
1671 av_frac_init(&st->pts, 0, 0,
1672 (int64_t)s->pts_num * st->codec.sample_rate);
1674 case CODEC_TYPE_VIDEO:
1675 av_frac_init(&st->pts, 0, 0,
1676 (int64_t)s->pts_num * st->codec.frame_rate);
1686 * Write a packet to an output media file. The packet shall contain
1687 * one audio or video frame.
1689 * @param s media file handle
1690 * @param stream_index stream index
1691 * @param buf buffer containing the frame data
1692 * @param size size of buffer
1693 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
1695 int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
1700 int ret, frame_size;
1702 st = s->streams[stream_index];
1703 pts_mask = (1LL << s->pts_wrap_bits) - 1;
1705 /* HACK/FIXME we skip all zero size audio packets so a encoder can pass pts by outputing zero size packets */
1706 if(st->codec.codec_type==CODEC_TYPE_AUDIO && size==0)
1709 ret = s->oformat->write_packet(s, stream_index, buf, size,
1710 st->pts.val & pts_mask);
1716 switch (st->codec.codec_type) {
1717 case CODEC_TYPE_AUDIO:
1718 frame_size = get_audio_frame_size(&st->codec, size);
1720 /* HACK/FIXME, we skip the initial 0-size packets as they are most likely equal to the encoder delay,
1721 but it would be better if we had the real timestamps from the encoder */
1722 if (frame_size >= 0 && (size || st->pts.num!=st->pts.den>>1 || st->pts.val)) {
1723 av_frac_add(&st->pts,
1724 (int64_t)s->pts_den * frame_size);
1727 case CODEC_TYPE_VIDEO:
1728 av_frac_add(&st->pts,
1729 (int64_t)s->pts_den * st->codec.frame_rate_base);
1738 * write the stream trailer to an output media file and and free the
1739 * file private data.
1741 * @param s media file handle
1742 * @return 0 if OK. AVERROR_xxx if error. */
1743 int av_write_trailer(AVFormatContext *s)
1746 ret = s->oformat->write_trailer(s);
1747 av_freep(&s->priv_data);
1751 /* "user interface" functions */
1753 void dump_format(AVFormatContext *ic,
1761 av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n",
1762 is_output ? "Output" : "Input",
1764 is_output ? ic->oformat->name : ic->iformat->name,
1765 is_output ? "to" : "from", url);
1767 av_log(NULL, AV_LOG_DEBUG, " Duration: ");
1768 if (ic->duration != AV_NOPTS_VALUE) {
1769 int hours, mins, secs, us;
1770 secs = ic->duration / AV_TIME_BASE;
1771 us = ic->duration % AV_TIME_BASE;
1776 av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs,
1777 (10 * us) / AV_TIME_BASE);
1779 av_log(NULL, AV_LOG_DEBUG, "N/A");
1781 av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
1783 av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
1785 av_log(NULL, AV_LOG_DEBUG, "N/A");
1787 av_log(NULL, AV_LOG_DEBUG, "\n");
1789 for(i=0;i<ic->nb_streams;i++) {
1790 AVStream *st = ic->streams[i];
1791 avcodec_string(buf, sizeof(buf), &st->codec, is_output);
1792 av_log(NULL, AV_LOG_DEBUG, " Stream #%d.%d", index, i);
1793 /* the pid is an important information, so we display it */
1794 /* XXX: add a generic system */
1796 flags = ic->oformat->flags;
1798 flags = ic->iformat->flags;
1799 if (flags & AVFMT_SHOW_IDS) {
1800 av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
1802 av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
1809 int frame_rate, frame_rate_base;
1812 static AbvEntry frame_abvs[] = {
1813 { "ntsc", 720, 480, 30000, 1001 },
1814 { "pal", 720, 576, 25, 1 },
1815 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
1816 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
1817 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
1818 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
1819 { "film", 352, 240, 24, 1 },
1820 { "ntsc-film", 352, 240, 24000, 1001 },
1821 { "sqcif", 128, 96, 0, 0 },
1822 { "qcif", 176, 144, 0, 0 },
1823 { "cif", 352, 288, 0, 0 },
1824 { "4cif", 704, 576, 0, 0 },
1827 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
1830 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
1832 int frame_width = 0, frame_height = 0;
1835 if (!strcmp(frame_abvs[i].abv, str)) {
1836 frame_width = frame_abvs[i].width;
1837 frame_height = frame_abvs[i].height;
1843 frame_width = strtol(p, (char **)&p, 10);
1846 frame_height = strtol(p, (char **)&p, 10);
1848 if (frame_width <= 0 || frame_height <= 0)
1850 *width_ptr = frame_width;
1851 *height_ptr = frame_height;
1855 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
1860 /* First, we check our abbreviation table */
1861 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
1862 if (!strcmp(frame_abvs[i].abv, arg)) {
1863 *frame_rate = frame_abvs[i].frame_rate;
1864 *frame_rate_base = frame_abvs[i].frame_rate_base;
1868 /* Then, we try to parse it as fraction */
1869 cp = strchr(arg, '/');
1872 *frame_rate = strtol(arg, &cpp, 10);
1873 if (cpp != arg || cpp == cp)
1874 *frame_rate_base = strtol(cp+1, &cpp, 10);
1879 /* Finally we give up and parse it as double */
1880 *frame_rate_base = DEFAULT_FRAME_RATE_BASE; //FIXME use av_d2q()
1881 *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
1883 if (!*frame_rate || !*frame_rate_base)
1890 * - If not a duration:
1891 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
1892 * Time is localtime unless Z is suffixed to the end. In this case GMT
1893 * Return the date in micro seconds since 1970
1895 * HH[:MM[:SS[.m...]]]
1898 int64_t parse_date(const char *datestr, int duration)
1904 static const char *date_fmt[] = {
1908 static const char *time_fmt[] = {
1917 time_t now = time(0);
1919 len = strlen(datestr);
1921 lastch = datestr[len - 1];
1924 is_utc = (lastch == 'z' || lastch == 'Z');
1926 memset(&dt, 0, sizeof(dt));
1931 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
1932 q = small_strptime(p, date_fmt[i], &dt);
1942 dt = *localtime(&now);
1944 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
1949 if (*p == 'T' || *p == 't' || *p == ' ')
1952 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
1953 q = small_strptime(p, time_fmt[i], &dt);
1959 q = small_strptime(p, time_fmt[0], &dt);
1961 dt.tm_sec = strtol(p, (char **)&q, 10);
1967 /* Now we have all the fields that we can get */
1972 return now * int64_t_C(1000000);
1976 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
1978 dt.tm_isdst = -1; /* unknown */
1991 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1994 val += n * (*q - '0');
2001 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
2003 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
2013 while (*p != '\0' && *p != '=' && *p != '&') {
2014 if ((q - tag) < sizeof(tag) - 1)
2022 while (*p != '&' && *p != '\0') {
2023 if ((q - arg) < arg_size - 1) {
2033 if (!strcmp(tag, tag1))
2042 /* Return in 'buf' the path with '%d' replaced by number. Also handles
2043 the '%0nd' format where 'n' is the total number of digits and
2044 '%%'. Return 0 if OK, and -1 if format error */
2045 int get_frame_filename(char *buf, int buf_size,
2046 const char *path, int number)
2049 char *q, buf1[20], c;
2050 int nd, len, percentd_found;
2062 while (isdigit(*p)) {
2063 nd = nd * 10 + *p++ - '0';
2066 } while (isdigit(c));
2075 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2077 if ((q - buf + len) > buf_size - 1)
2079 memcpy(q, buf1, len);
2087 if ((q - buf) < buf_size - 1)
2091 if (!percentd_found)
2101 * Print nice hexa dump of a buffer
2102 * @param f stream for output
2104 * @param size buffer size
2106 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2110 for(i=0;i<size;i+=16) {
2114 fprintf(f, "%08x ", i);
2117 fprintf(f, " %02x", buf[i+j]);
2122 for(j=0;j<len;j++) {
2124 if (c < ' ' || c > '~')
2126 fprintf(f, "%c", c);
2133 * Print on 'f' a nice dump of a packet
2134 * @param f stream for output
2135 * @param pkt packet to dump
2136 * @param dump_payload true if the payload must be displayed too
2138 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2140 fprintf(f, "stream #%d:\n", pkt->stream_index);
2141 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2142 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2143 /* DTS is _always_ valid after av_read_frame() */
2144 fprintf(f, " dts=");
2145 if (pkt->dts == AV_NOPTS_VALUE)
2148 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2149 /* PTS may be not known if B frames are present */
2150 fprintf(f, " pts=");
2151 if (pkt->pts == AV_NOPTS_VALUE)
2154 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2156 fprintf(f, " size=%d\n", pkt->size);
2158 av_hex_dump(f, pkt->data, pkt->size);
2161 void url_split(char *proto, int proto_size,
2162 char *hostname, int hostname_size,
2164 char *path, int path_size,
2175 while (*p != ':' && *p != '\0') {
2176 if ((q - proto) < proto_size - 1)
2185 if (hostname_size > 0)
2195 while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
2196 if ((q - hostname) < hostname_size - 1)
2200 if (hostname_size > 0)
2204 port = strtoul(p, (char **)&p, 10);
2209 pstrcpy(path, path_size, p);
2213 * Set the pts for a given stream
2215 * @param pts_wrap_bits number of bits effectively used by the pts
2216 * (used for wrap control, 33 is the value for MPEG)
2217 * @param pts_num numerator to convert to seconds (MPEG: 1)
2218 * @param pts_den denominator to convert to seconds (MPEG: 90000)
2220 void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
2221 int pts_num, int pts_den)
2223 s->pts_wrap_bits = pts_wrap_bits;
2224 s->pts_num = pts_num;
2225 s->pts_den = pts_den;
2228 /* fraction handling */
2231 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2232 * as 0 <= num < den.
2234 * @param f fractional number
2235 * @param val integer value
2236 * @param num must be >= 0
2237 * @param den must be >= 1
2239 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2251 /* set f to (val + 0.5) */
2252 void av_frac_set(AVFrac *f, int64_t val)
2255 f->num = f->den >> 1;
2259 * Fractionnal addition to f: f = f + (incr / f->den)
2261 * @param f fractional number
2262 * @param incr increment, can be positive or negative
2264 void av_frac_add(AVFrac *f, int64_t incr)
2268 num = f->num + incr;
2271 f->val += num / den;
2277 } else if (num >= den) {
2278 f->val += num / den;
2285 * register a new image format
2286 * @param img_fmt Image format descriptor
2288 void av_register_image_format(AVImageFormat *img_fmt)
2292 p = &first_image_format;
2293 while (*p != NULL) p = &(*p)->next;
2295 img_fmt->next = NULL;
2298 /* guess image format */
2299 AVImageFormat *av_probe_image_format(AVProbeData *pd)
2301 AVImageFormat *fmt1, *fmt;
2302 int score, score_max;
2306 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2307 if (fmt1->img_probe) {
2308 score = fmt1->img_probe(pd);
2309 if (score > score_max) {
2318 AVImageFormat *guess_image_format(const char *filename)
2320 AVImageFormat *fmt1;
2322 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2323 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2330 * Read an image from a stream.
2331 * @param gb byte stream containing the image
2332 * @param fmt image format, NULL if probing is required
2334 int av_read_image(ByteIOContext *pb, const char *filename,
2336 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2338 char buf[PROBE_BUF_SIZE];
2339 AVProbeData probe_data, *pd = &probe_data;
2344 pd->filename = filename;
2346 pos = url_ftell(pb);
2347 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2348 url_fseek(pb, pos, SEEK_SET);
2349 fmt = av_probe_image_format(pd);
2352 return AVERROR_NOFMT;
2353 ret = fmt->img_read(pb, alloc_cb, opaque);
2358 * Write an image to a stream.
2359 * @param pb byte stream for the image output
2360 * @param fmt image format
2361 * @param img image data and informations
2363 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2365 return fmt->img_write(pb, img);