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++;
920 index= st->nb_index_entries++;
925 ie->timestamp = timestamp;
926 ie->min_distance= distance;
932 /* build an index for raw streams using a parser */
933 static void av_build_index_raw(AVFormatContext *s)
935 AVPacket pkt1, *pkt = &pkt1;
940 av_read_frame_flush(s);
941 url_fseek(&s->pb, s->data_offset, SEEK_SET);
944 ret = av_read_frame(s, pkt);
947 if (pkt->stream_index == 0 && st->parser &&
948 (pkt->flags & PKT_FLAG_KEY)) {
949 av_add_index_entry(st, st->parser->frame_offset, pkt->dts,
950 0, AVINDEX_KEYFRAME);
956 /* return TRUE if we deal with a raw stream (raw codec data and
958 static int is_raw_stream(AVFormatContext *s)
962 if (s->nb_streams != 1)
965 if (!st->need_parsing)
970 /* return the largest index entry whose timestamp is <=
972 int av_index_search_timestamp(AVStream *st, int wanted_timestamp)
974 AVIndexEntry *entries= st->index_entries;
975 int nb_entries= st->nb_index_entries;
986 m = (a + b + 1) >> 1;
987 timestamp = entries[m].timestamp;
988 if (timestamp > wanted_timestamp) {
997 static int av_seek_frame_generic(AVFormatContext *s,
998 int stream_index, int64_t timestamp)
1004 if (!s->index_built) {
1005 if (is_raw_stream(s)) {
1006 av_build_index_raw(s);
1013 if (stream_index < 0)
1015 st = s->streams[stream_index];
1016 index = av_index_search_timestamp(st, timestamp);
1020 /* now we have found the index, we can seek */
1021 ie = &st->index_entries[index];
1022 av_read_frame_flush(s);
1023 url_fseek(&s->pb, ie->pos, SEEK_SET);
1024 st->cur_dts = ie->timestamp;
1029 * Seek to the key frame just before the frame at timestamp
1030 * 'timestamp' in 'stream_index'. If stream_index is (-1), a default
1031 * stream is selected
1033 int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp)
1037 av_read_frame_flush(s);
1039 /* first, we try the format specific seek */
1040 if (s->iformat->read_seek)
1041 ret = s->iformat->read_seek(s, stream_index, timestamp);
1048 return av_seek_frame_generic(s, stream_index, timestamp);
1051 /*******************************************************/
1053 /* return TRUE if the stream has accurate timings for at least one component */
1054 static int av_has_timings(AVFormatContext *ic)
1059 for(i = 0;i < ic->nb_streams; i++) {
1060 st = ic->streams[i];
1061 if (st->start_time != AV_NOPTS_VALUE &&
1062 st->duration != AV_NOPTS_VALUE)
1068 /* estimate the stream timings from the one of each components. Also
1069 compute the global bitrate if possible */
1070 static void av_update_stream_timings(AVFormatContext *ic)
1072 int64_t start_time, end_time, end_time1;
1076 start_time = MAXINT64;
1077 end_time = MININT64;
1078 for(i = 0;i < ic->nb_streams; i++) {
1079 st = ic->streams[i];
1080 if (st->start_time != AV_NOPTS_VALUE) {
1081 if (st->start_time < start_time)
1082 start_time = st->start_time;
1083 if (st->duration != AV_NOPTS_VALUE) {
1084 end_time1 = st->start_time + st->duration;
1085 if (end_time1 > end_time)
1086 end_time = end_time1;
1090 if (start_time != MAXINT64) {
1091 ic->start_time = start_time;
1092 if (end_time != MAXINT64) {
1093 ic->duration = end_time - start_time;
1094 if (ic->file_size > 0) {
1095 /* compute the bit rate */
1096 ic->bit_rate = (double)ic->file_size * 8.0 * AV_TIME_BASE /
1097 (double)ic->duration;
1104 static void fill_all_stream_timings(AVFormatContext *ic)
1109 av_update_stream_timings(ic);
1110 for(i = 0;i < ic->nb_streams; i++) {
1111 st = ic->streams[i];
1112 if (st->start_time == AV_NOPTS_VALUE) {
1113 st->start_time = ic->start_time;
1114 st->duration = ic->duration;
1119 static void av_estimate_timings_from_bit_rate(AVFormatContext *ic)
1121 int64_t filesize, duration;
1125 /* if bit_rate is already set, we believe it */
1126 if (ic->bit_rate == 0) {
1128 for(i=0;i<ic->nb_streams;i++) {
1129 st = ic->streams[i];
1130 bit_rate += st->codec.bit_rate;
1132 ic->bit_rate = bit_rate;
1135 /* if duration is already set, we believe it */
1136 if (ic->duration == AV_NOPTS_VALUE &&
1137 ic->bit_rate != 0 &&
1138 ic->file_size != 0) {
1139 filesize = ic->file_size;
1141 duration = (int64_t)((8 * AV_TIME_BASE * (double)filesize) / (double)ic->bit_rate);
1142 for(i = 0; i < ic->nb_streams; i++) {
1143 st = ic->streams[i];
1144 if (st->start_time == AV_NOPTS_VALUE ||
1145 st->duration == AV_NOPTS_VALUE) {
1147 st->duration = duration;
1154 #define DURATION_MAX_READ_SIZE 250000
1156 /* only usable for MPEG-PS streams */
1157 static void av_estimate_timings_from_pts(AVFormatContext *ic)
1159 AVPacket pkt1, *pkt = &pkt1;
1161 int read_size, i, ret;
1162 int64_t start_time, end_time, end_time1;
1163 int64_t filesize, offset, duration;
1165 /* free previous packet */
1166 if (ic->cur_st && ic->cur_st->parser)
1167 av_free_packet(&ic->cur_pkt);
1170 /* flush packet queue */
1171 flush_packet_queue(ic);
1174 /* we read the first packets to get the first PTS (not fully
1175 accurate, but it is enough now) */
1176 url_fseek(&ic->pb, 0, SEEK_SET);
1179 if (read_size >= DURATION_MAX_READ_SIZE)
1181 /* if all info is available, we can stop */
1182 for(i = 0;i < ic->nb_streams; i++) {
1183 st = ic->streams[i];
1184 if (st->start_time == AV_NOPTS_VALUE)
1187 if (i == ic->nb_streams)
1190 ret = av_read_packet(ic, pkt);
1193 read_size += pkt->size;
1194 st = ic->streams[pkt->stream_index];
1195 if (pkt->pts != AV_NOPTS_VALUE) {
1196 if (st->start_time == AV_NOPTS_VALUE)
1197 st->start_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
1199 av_free_packet(pkt);
1202 /* we compute the minimum start_time and use it as default */
1203 start_time = MAXINT64;
1204 for(i = 0; i < ic->nb_streams; i++) {
1205 st = ic->streams[i];
1206 if (st->start_time != AV_NOPTS_VALUE &&
1207 st->start_time < start_time)
1208 start_time = st->start_time;
1210 if (start_time != MAXINT64)
1211 ic->start_time = start_time;
1213 /* estimate the end time (duration) */
1214 /* XXX: may need to support wrapping */
1215 filesize = ic->file_size;
1216 offset = filesize - DURATION_MAX_READ_SIZE;
1220 url_fseek(&ic->pb, offset, SEEK_SET);
1223 if (read_size >= DURATION_MAX_READ_SIZE)
1225 /* if all info is available, we can stop */
1226 for(i = 0;i < ic->nb_streams; i++) {
1227 st = ic->streams[i];
1228 if (st->duration == AV_NOPTS_VALUE)
1231 if (i == ic->nb_streams)
1234 ret = av_read_packet(ic, pkt);
1237 read_size += pkt->size;
1238 st = ic->streams[pkt->stream_index];
1239 if (pkt->pts != AV_NOPTS_VALUE) {
1240 end_time = (int64_t)((double)pkt->pts * ic->pts_num * (double)AV_TIME_BASE / ic->pts_den);
1241 duration = end_time - st->start_time;
1243 if (st->duration == AV_NOPTS_VALUE ||
1244 st->duration < duration)
1245 st->duration = duration;
1248 av_free_packet(pkt);
1251 /* estimate total duration */
1252 end_time = MININT64;
1253 for(i = 0;i < ic->nb_streams; i++) {
1254 st = ic->streams[i];
1255 if (st->duration != AV_NOPTS_VALUE) {
1256 end_time1 = st->start_time + st->duration;
1257 if (end_time1 > end_time)
1258 end_time = end_time1;
1262 /* update start_time (new stream may have been created, so we do
1264 if (ic->start_time != AV_NOPTS_VALUE) {
1265 for(i = 0; i < ic->nb_streams; i++) {
1266 st = ic->streams[i];
1267 if (st->start_time == AV_NOPTS_VALUE)
1268 st->start_time = ic->start_time;
1272 if (end_time != MININT64) {
1273 /* put dummy values for duration if needed */
1274 for(i = 0;i < ic->nb_streams; i++) {
1275 st = ic->streams[i];
1276 if (st->duration == AV_NOPTS_VALUE &&
1277 st->start_time != AV_NOPTS_VALUE)
1278 st->duration = end_time - st->start_time;
1280 ic->duration = end_time - ic->start_time;
1283 url_fseek(&ic->pb, 0, SEEK_SET);
1286 static void av_estimate_timings(AVFormatContext *ic)
1291 /* get the file size, if possible */
1292 if (ic->iformat->flags & AVFMT_NOFILE) {
1295 h = url_fileno(&ic->pb);
1296 file_size = url_filesize(h);
1300 ic->file_size = file_size;
1302 if (ic->iformat == &mpegps_demux) {
1303 /* get accurate estimate from the PTSes */
1304 av_estimate_timings_from_pts(ic);
1305 } else if (av_has_timings(ic)) {
1306 /* at least one components has timings - we use them for all
1308 fill_all_stream_timings(ic);
1310 /* less precise: use bit rate info */
1311 av_estimate_timings_from_bit_rate(ic);
1313 av_update_stream_timings(ic);
1319 for(i = 0;i < ic->nb_streams; i++) {
1320 st = ic->streams[i];
1321 printf("%d: start_time: %0.3f duration: %0.3f\n",
1322 i, (double)st->start_time / AV_TIME_BASE,
1323 (double)st->duration / AV_TIME_BASE);
1325 printf("stream: start_time: %0.3f duration: %0.3f bitrate=%d kb/s\n",
1326 (double)ic->start_time / AV_TIME_BASE,
1327 (double)ic->duration / AV_TIME_BASE,
1328 ic->bit_rate / 1000);
1333 static int has_codec_parameters(AVCodecContext *enc)
1336 switch(enc->codec_type) {
1337 case CODEC_TYPE_AUDIO:
1338 val = enc->sample_rate;
1340 case CODEC_TYPE_VIDEO:
1350 static int try_decode_frame(AVStream *st, const uint8_t *data, int size)
1354 int got_picture, ret;
1357 codec = avcodec_find_decoder(st->codec.codec_id);
1360 ret = avcodec_open(&st->codec, codec);
1363 switch(st->codec.codec_type) {
1364 case CODEC_TYPE_VIDEO:
1365 ret = avcodec_decode_video(&st->codec, &picture,
1366 &got_picture, (uint8_t *)data, size);
1368 case CODEC_TYPE_AUDIO:
1369 samples = av_malloc(AVCODEC_MAX_AUDIO_FRAME_SIZE);
1372 ret = avcodec_decode_audio(&st->codec, samples,
1373 &got_picture, (uint8_t *)data, size);
1380 avcodec_close(&st->codec);
1384 /* absolute maximum size we read until we abort */
1385 #define MAX_READ_SIZE 5000000
1387 /* maximum duration until we stop analysing the stream */
1388 #define MAX_STREAM_DURATION ((int)(AV_TIME_BASE * 1.0))
1391 * Read the beginning of a media file to get stream information. This
1392 * is useful for file formats with no headers such as MPEG. This
1393 * function also compute the real frame rate in case of mpeg2 repeat
1396 * @param ic media file handle
1397 * @return >=0 if OK. AVERROR_xxx if error.
1399 int av_find_stream_info(AVFormatContext *ic)
1401 int i, count, ret, read_size;
1403 AVPacket pkt1, *pkt;
1404 AVPacketList *pktl=NULL, **ppktl;
1408 ppktl = &ic->packet_buffer;
1410 /* check if one codec still needs to be handled */
1411 for(i=0;i<ic->nb_streams;i++) {
1412 st = ic->streams[i];
1413 if (!has_codec_parameters(&st->codec))
1416 if (i == ic->nb_streams) {
1417 /* NOTE: if the format has no header, then we need to read
1418 some packets to get most of the streams, so we cannot
1420 if (!(ic->ctx_flags & AVFMTCTX_NOHEADER)) {
1421 /* if we found the info for all the codecs, we can stop */
1426 /* we did not get all the codec info, but we read too much data */
1427 if (read_size >= MAX_READ_SIZE) {
1433 /* NOTE: a new stream can be added there if no header in file
1434 (AVFMTCTX_NOHEADER) */
1435 ret = av_read_frame_internal(ic, &pkt1);
1438 ret = -1; /* we could not have all the codec parameters before EOF */
1439 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) &&
1440 i == ic->nb_streams)
1445 pktl = av_mallocz(sizeof(AVPacketList));
1447 ret = AVERROR_NOMEM;
1451 /* add the packet in the buffered packet list */
1453 ppktl = &pktl->next;
1458 /* duplicate the packet */
1459 if (av_dup_packet(pkt) < 0) {
1460 ret = AVERROR_NOMEM;
1464 read_size += pkt->size;
1466 st = ic->streams[pkt->stream_index];
1467 st->codec_info_duration += pkt->duration;
1468 if (pkt->duration != 0)
1469 st->codec_info_nb_frames++;
1471 /* if still no information, we try to open the codec and to
1472 decompress the frame. We try to avoid that in most cases as
1473 it takes longer and uses more memory. For MPEG4, we need to
1474 decompress for Quicktime. */
1475 if (!has_codec_parameters(&st->codec) &&
1476 (st->codec.codec_id == CODEC_ID_FLV1 ||
1477 st->codec.codec_id == CODEC_ID_H264 ||
1478 st->codec.codec_id == CODEC_ID_H263 ||
1479 (st->codec.codec_id == CODEC_ID_MPEG4 && !st->need_parsing)))
1480 try_decode_frame(st, pkt->data, pkt->size);
1482 if (st->codec_info_duration >= MAX_STREAM_DURATION) {
1488 /* set real frame rate info */
1489 for(i=0;i<ic->nb_streams;i++) {
1490 st = ic->streams[i];
1491 if (st->codec.codec_type == CODEC_TYPE_VIDEO) {
1492 /* compute the real frame rate for telecine */
1493 if ((st->codec.codec_id == CODEC_ID_MPEG1VIDEO ||
1494 st->codec.codec_id == CODEC_ID_MPEG2VIDEO) &&
1495 st->codec.sub_id == 2) {
1496 if (st->codec_info_nb_frames >= 20) {
1497 float coded_frame_rate, est_frame_rate;
1498 est_frame_rate = ((double)st->codec_info_nb_frames * AV_TIME_BASE) /
1499 (double)st->codec_info_duration ;
1500 coded_frame_rate = (double)st->codec.frame_rate /
1501 (double)st->codec.frame_rate_base;
1503 printf("telecine: coded_frame_rate=%0.3f est_frame_rate=%0.3f\n",
1504 coded_frame_rate, est_frame_rate);
1506 /* if we detect that it could be a telecine, we
1507 signal it. It would be better to do it at a
1508 higher level as it can change in a film */
1509 if (coded_frame_rate >= 24.97 &&
1510 (est_frame_rate >= 23.5 && est_frame_rate < 24.5)) {
1511 st->r_frame_rate = 24024;
1512 st->r_frame_rate_base = 1001;
1516 /* if no real frame rate, use the codec one */
1517 if (!st->r_frame_rate){
1518 st->r_frame_rate = st->codec.frame_rate;
1519 st->r_frame_rate_base = st->codec.frame_rate_base;
1524 av_estimate_timings(ic);
1528 /*******************************************************/
1531 * start playing a network based stream (e.g. RTSP stream) at the
1534 int av_read_play(AVFormatContext *s)
1536 if (!s->iformat->read_play)
1537 return AVERROR_NOTSUPP;
1538 return s->iformat->read_play(s);
1542 * pause a network based stream (e.g. RTSP stream). Use av_read_play()
1545 int av_read_pause(AVFormatContext *s)
1547 if (!s->iformat->read_pause)
1548 return AVERROR_NOTSUPP;
1549 return s->iformat->read_pause(s);
1553 * Close a media file (but not its codecs)
1555 * @param s media file handle
1557 void av_close_input_file(AVFormatContext *s)
1559 int i, must_open_file;
1562 /* free previous packet */
1563 if (s->cur_st && s->cur_st->parser)
1564 av_free_packet(&s->cur_pkt);
1566 if (s->iformat->read_close)
1567 s->iformat->read_close(s);
1568 for(i=0;i<s->nb_streams;i++) {
1569 /* free all data in a stream component */
1572 av_parser_close(st->parser);
1574 av_free(st->index_entries);
1577 flush_packet_queue(s);
1579 if (s->iformat->flags & AVFMT_NOFILE) {
1582 if (must_open_file) {
1585 av_freep(&s->priv_data);
1590 * Add a new stream to a media file. Can only be called in the
1591 * read_header function. If the flag AVFMTCTX_NOHEADER is in the
1592 * format context, then new streams can be added in read_packet too.
1595 * @param s media file handle
1596 * @param id file format dependent stream id
1598 AVStream *av_new_stream(AVFormatContext *s, int id)
1602 if (s->nb_streams >= MAX_STREAMS)
1605 st = av_mallocz(sizeof(AVStream));
1608 avcodec_get_context_defaults(&st->codec);
1610 /* no default bitrate if decoding */
1611 st->codec.bit_rate = 0;
1613 st->index = s->nb_streams;
1615 st->start_time = AV_NOPTS_VALUE;
1616 st->duration = AV_NOPTS_VALUE;
1617 s->streams[s->nb_streams++] = st;
1621 /************************************************************/
1622 /* output media file */
1624 int av_set_parameters(AVFormatContext *s, AVFormatParameters *ap)
1628 if (s->oformat->priv_data_size > 0) {
1629 s->priv_data = av_mallocz(s->oformat->priv_data_size);
1631 return AVERROR_NOMEM;
1633 s->priv_data = NULL;
1635 if (s->oformat->set_parameters) {
1636 ret = s->oformat->set_parameters(s, ap);
1644 * allocate the stream private data and write the stream header to an
1647 * @param s media file handle
1648 * @return 0 if OK. AVERROR_xxx if error.
1650 int av_write_header(AVFormatContext *s)
1655 /* default pts settings is MPEG like */
1656 av_set_pts_info(s, 33, 1, 90000);
1657 ret = s->oformat->write_header(s);
1661 /* init PTS generation */
1662 for(i=0;i<s->nb_streams;i++) {
1665 switch (st->codec.codec_type) {
1666 case CODEC_TYPE_AUDIO:
1667 av_frac_init(&st->pts, 0, 0,
1668 (int64_t)s->pts_num * st->codec.sample_rate);
1670 case CODEC_TYPE_VIDEO:
1671 av_frac_init(&st->pts, 0, 0,
1672 (int64_t)s->pts_num * st->codec.frame_rate);
1682 * Write a packet to an output media file. The packet shall contain
1683 * one audio or video frame.
1685 * @param s media file handle
1686 * @param stream_index stream index
1687 * @param buf buffer containing the frame data
1688 * @param size size of buffer
1689 * @return < 0 if error, = 0 if OK, 1 if end of stream wanted.
1691 int av_write_frame(AVFormatContext *s, int stream_index, const uint8_t *buf,
1696 int ret, frame_size;
1698 st = s->streams[stream_index];
1699 pts_mask = (1LL << s->pts_wrap_bits) - 1;
1700 ret = s->oformat->write_packet(s, stream_index, buf, size,
1701 st->pts.val & pts_mask);
1706 switch (st->codec.codec_type) {
1707 case CODEC_TYPE_AUDIO:
1708 frame_size = get_audio_frame_size(&st->codec, size);
1709 if (frame_size >= 0) {
1710 av_frac_add(&st->pts,
1711 (int64_t)s->pts_den * frame_size);
1714 case CODEC_TYPE_VIDEO:
1715 av_frac_add(&st->pts,
1716 (int64_t)s->pts_den * st->codec.frame_rate_base);
1725 * write the stream trailer to an output media file and and free the
1726 * file private data.
1728 * @param s media file handle
1729 * @return 0 if OK. AVERROR_xxx if error. */
1730 int av_write_trailer(AVFormatContext *s)
1733 ret = s->oformat->write_trailer(s);
1734 av_freep(&s->priv_data);
1738 /* "user interface" functions */
1740 void dump_format(AVFormatContext *ic,
1748 av_log(NULL, AV_LOG_DEBUG, "%s #%d, %s, %s '%s':\n",
1749 is_output ? "Output" : "Input",
1751 is_output ? ic->oformat->name : ic->iformat->name,
1752 is_output ? "to" : "from", url);
1754 av_log(NULL, AV_LOG_DEBUG, " Duration: ");
1755 if (ic->duration != AV_NOPTS_VALUE) {
1756 int hours, mins, secs, us;
1757 secs = ic->duration / AV_TIME_BASE;
1758 us = ic->duration % AV_TIME_BASE;
1763 av_log(NULL, AV_LOG_DEBUG, "%02d:%02d:%02d.%01d", hours, mins, secs,
1764 (10 * us) / AV_TIME_BASE);
1766 av_log(NULL, AV_LOG_DEBUG, "N/A");
1768 av_log(NULL, AV_LOG_DEBUG, ", bitrate: ");
1770 av_log(NULL, AV_LOG_DEBUG,"%d kb/s", ic->bit_rate / 1000);
1772 av_log(NULL, AV_LOG_DEBUG, "N/A");
1774 av_log(NULL, AV_LOG_DEBUG, "\n");
1776 for(i=0;i<ic->nb_streams;i++) {
1777 AVStream *st = ic->streams[i];
1778 avcodec_string(buf, sizeof(buf), &st->codec, is_output);
1779 av_log(NULL, AV_LOG_DEBUG, " Stream #%d.%d", index, i);
1780 /* the pid is an important information, so we display it */
1781 /* XXX: add a generic system */
1783 flags = ic->oformat->flags;
1785 flags = ic->iformat->flags;
1786 if (flags & AVFMT_SHOW_IDS) {
1787 av_log(NULL, AV_LOG_DEBUG, "[0x%x]", st->id);
1789 av_log(NULL, AV_LOG_DEBUG, ": %s\n", buf);
1796 int frame_rate, frame_rate_base;
1799 static AbvEntry frame_abvs[] = {
1800 { "ntsc", 720, 480, 30000, 1001 },
1801 { "pal", 720, 576, 25, 1 },
1802 { "qntsc", 352, 240, 30000, 1001 }, /* VCD compliant ntsc */
1803 { "qpal", 352, 288, 25, 1 }, /* VCD compliant pal */
1804 { "sntsc", 640, 480, 30000, 1001 }, /* square pixel ntsc */
1805 { "spal", 768, 576, 25, 1 }, /* square pixel pal */
1806 { "film", 352, 240, 24, 1 },
1807 { "ntsc-film", 352, 240, 24000, 1001 },
1808 { "sqcif", 128, 96, 0, 0 },
1809 { "qcif", 176, 144, 0, 0 },
1810 { "cif", 352, 288, 0, 0 },
1811 { "4cif", 704, 576, 0, 0 },
1814 int parse_image_size(int *width_ptr, int *height_ptr, const char *str)
1817 int n = sizeof(frame_abvs) / sizeof(AbvEntry);
1819 int frame_width = 0, frame_height = 0;
1822 if (!strcmp(frame_abvs[i].abv, str)) {
1823 frame_width = frame_abvs[i].width;
1824 frame_height = frame_abvs[i].height;
1830 frame_width = strtol(p, (char **)&p, 10);
1833 frame_height = strtol(p, (char **)&p, 10);
1835 if (frame_width <= 0 || frame_height <= 0)
1837 *width_ptr = frame_width;
1838 *height_ptr = frame_height;
1842 int parse_frame_rate(int *frame_rate, int *frame_rate_base, const char *arg)
1847 /* First, we check our abbreviation table */
1848 for (i = 0; i < sizeof(frame_abvs)/sizeof(*frame_abvs); ++i)
1849 if (!strcmp(frame_abvs[i].abv, arg)) {
1850 *frame_rate = frame_abvs[i].frame_rate;
1851 *frame_rate_base = frame_abvs[i].frame_rate_base;
1855 /* Then, we try to parse it as fraction */
1856 cp = strchr(arg, '/');
1859 *frame_rate = strtol(arg, &cpp, 10);
1860 if (cpp != arg || cpp == cp)
1861 *frame_rate_base = strtol(cp+1, &cpp, 10);
1866 /* Finally we give up and parse it as double */
1867 *frame_rate_base = DEFAULT_FRAME_RATE_BASE;
1868 *frame_rate = (int)(strtod(arg, 0) * (*frame_rate_base) + 0.5);
1870 if (!*frame_rate || !*frame_rate_base)
1877 * - If not a duration:
1878 * [{YYYY-MM-DD|YYYYMMDD}]{T| }{HH[:MM[:SS[.m...]]][Z]|HH[MM[SS[.m...]]][Z]}
1879 * Time is localtime unless Z is suffixed to the end. In this case GMT
1880 * Return the date in micro seconds since 1970
1882 * HH[:MM[:SS[.m...]]]
1885 int64_t parse_date(const char *datestr, int duration)
1891 static const char *date_fmt[] = {
1895 static const char *time_fmt[] = {
1902 time_t now = time(0);
1904 len = strlen(datestr);
1906 lastch = datestr[len - 1];
1909 is_utc = (lastch == 'z' || lastch == 'Z');
1911 memset(&dt, 0, sizeof(dt));
1916 for (i = 0; i < sizeof(date_fmt) / sizeof(date_fmt[0]); i++) {
1917 q = small_strptime(p, date_fmt[i], &dt);
1927 dt = *localtime(&now);
1929 dt.tm_hour = dt.tm_min = dt.tm_sec = 0;
1934 if (*p == 'T' || *p == 't' || *p == ' ')
1937 for (i = 0; i < sizeof(time_fmt) / sizeof(time_fmt[0]); i++) {
1938 q = small_strptime(p, time_fmt[i], &dt);
1944 q = small_strptime(p, time_fmt[0], &dt);
1946 dt.tm_sec = strtol(p, (char **)&q, 10);
1952 /* Now we have all the fields that we can get */
1957 return now * int64_t_C(1000000);
1961 t = dt.tm_hour * 3600 + dt.tm_min * 60 + dt.tm_sec;
1963 dt.tm_isdst = -1; /* unknown */
1976 for (val = 0, n = 100000; n >= 1; n /= 10, q++) {
1979 val += n * (*q - '0');
1986 /* syntax: '?tag1=val1&tag2=val2...'. Little URL decoding is done. Return
1988 int find_info_tag(char *arg, int arg_size, const char *tag1, const char *info)
1998 while (*p != '\0' && *p != '=' && *p != '&') {
1999 if ((q - tag) < sizeof(tag) - 1)
2007 while (*p != '&' && *p != '\0') {
2008 if ((q - arg) < arg_size - 1) {
2018 if (!strcmp(tag, tag1))
2027 /* Return in 'buf' the path with '%d' replaced by number. Also handles
2028 the '%0nd' format where 'n' is the total number of digits and
2029 '%%'. Return 0 if OK, and -1 if format error */
2030 int get_frame_filename(char *buf, int buf_size,
2031 const char *path, int number)
2034 char *q, buf1[20], c;
2035 int nd, len, percentd_found;
2047 while (isdigit(*p)) {
2048 nd = nd * 10 + *p++ - '0';
2051 } while (isdigit(c));
2060 snprintf(buf1, sizeof(buf1), "%0*d", nd, number);
2062 if ((q - buf + len) > buf_size - 1)
2064 memcpy(q, buf1, len);
2072 if ((q - buf) < buf_size - 1)
2076 if (!percentd_found)
2086 * Print nice hexa dump of a buffer
2087 * @param f stream for output
2089 * @param size buffer size
2091 void av_hex_dump(FILE *f, uint8_t *buf, int size)
2095 for(i=0;i<size;i+=16) {
2099 fprintf(f, "%08x ", i);
2102 fprintf(f, " %02x", buf[i+j]);
2107 for(j=0;j<len;j++) {
2109 if (c < ' ' || c > '~')
2111 fprintf(f, "%c", c);
2118 * Print on 'f' a nice dump of a packet
2119 * @param f stream for output
2120 * @param pkt packet to dump
2121 * @param dump_payload true if the payload must be displayed too
2123 void av_pkt_dump(FILE *f, AVPacket *pkt, int dump_payload)
2125 fprintf(f, "stream #%d:\n", pkt->stream_index);
2126 fprintf(f, " keyframe=%d\n", ((pkt->flags & PKT_FLAG_KEY) != 0));
2127 fprintf(f, " duration=%0.3f\n", (double)pkt->duration / AV_TIME_BASE);
2128 /* DTS is _always_ valid after av_read_frame() */
2129 fprintf(f, " dts=");
2130 if (pkt->dts == AV_NOPTS_VALUE)
2133 fprintf(f, "%0.3f", (double)pkt->dts / AV_TIME_BASE);
2134 /* PTS may be not known if B frames are present */
2135 fprintf(f, " pts=");
2136 if (pkt->pts == AV_NOPTS_VALUE)
2139 fprintf(f, "%0.3f", (double)pkt->pts / AV_TIME_BASE);
2141 fprintf(f, " size=%d\n", pkt->size);
2143 av_hex_dump(f, pkt->data, pkt->size);
2146 void url_split(char *proto, int proto_size,
2147 char *hostname, int hostname_size,
2149 char *path, int path_size,
2160 while (*p != ':' && *p != '\0') {
2161 if ((q - proto) < proto_size - 1)
2170 if (hostname_size > 0)
2180 while (*p != ':' && *p != '/' && *p != '?' && *p != '\0') {
2181 if ((q - hostname) < hostname_size - 1)
2185 if (hostname_size > 0)
2189 port = strtoul(p, (char **)&p, 10);
2194 pstrcpy(path, path_size, p);
2198 * Set the pts for a given stream
2200 * @param pts_wrap_bits number of bits effectively used by the pts
2201 * (used for wrap control, 33 is the value for MPEG)
2202 * @param pts_num numerator to convert to seconds (MPEG: 1)
2203 * @param pts_den denominator to convert to seconds (MPEG: 90000)
2205 void av_set_pts_info(AVFormatContext *s, int pts_wrap_bits,
2206 int pts_num, int pts_den)
2208 s->pts_wrap_bits = pts_wrap_bits;
2209 s->pts_num = pts_num;
2210 s->pts_den = pts_den;
2213 /* fraction handling */
2216 * f = val + (num / den) + 0.5. 'num' is normalized so that it is such
2217 * as 0 <= num < den.
2219 * @param f fractional number
2220 * @param val integer value
2221 * @param num must be >= 0
2222 * @param den must be >= 1
2224 void av_frac_init(AVFrac *f, int64_t val, int64_t num, int64_t den)
2236 /* set f to (val + 0.5) */
2237 void av_frac_set(AVFrac *f, int64_t val)
2240 f->num = f->den >> 1;
2244 * Fractionnal addition to f: f = f + (incr / f->den)
2246 * @param f fractional number
2247 * @param incr increment, can be positive or negative
2249 void av_frac_add(AVFrac *f, int64_t incr)
2253 num = f->num + incr;
2256 f->val += num / den;
2262 } else if (num >= den) {
2263 f->val += num / den;
2270 * register a new image format
2271 * @param img_fmt Image format descriptor
2273 void av_register_image_format(AVImageFormat *img_fmt)
2277 p = &first_image_format;
2278 while (*p != NULL) p = &(*p)->next;
2280 img_fmt->next = NULL;
2283 /* guess image format */
2284 AVImageFormat *av_probe_image_format(AVProbeData *pd)
2286 AVImageFormat *fmt1, *fmt;
2287 int score, score_max;
2291 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2292 if (fmt1->img_probe) {
2293 score = fmt1->img_probe(pd);
2294 if (score > score_max) {
2303 AVImageFormat *guess_image_format(const char *filename)
2305 AVImageFormat *fmt1;
2307 for(fmt1 = first_image_format; fmt1 != NULL; fmt1 = fmt1->next) {
2308 if (fmt1->extensions && match_ext(filename, fmt1->extensions))
2315 * Read an image from a stream.
2316 * @param gb byte stream containing the image
2317 * @param fmt image format, NULL if probing is required
2319 int av_read_image(ByteIOContext *pb, const char *filename,
2321 int (*alloc_cb)(void *, AVImageInfo *info), void *opaque)
2323 char buf[PROBE_BUF_SIZE];
2324 AVProbeData probe_data, *pd = &probe_data;
2329 pd->filename = filename;
2331 pos = url_ftell(pb);
2332 pd->buf_size = get_buffer(pb, buf, PROBE_BUF_SIZE);
2333 url_fseek(pb, pos, SEEK_SET);
2334 fmt = av_probe_image_format(pd);
2337 return AVERROR_NOFMT;
2338 ret = fmt->img_read(pb, alloc_cb, opaque);
2343 * Write an image to a stream.
2344 * @param pb byte stream for the image output
2345 * @param fmt image format
2346 * @param img image data and informations
2348 int av_write_image(ByteIOContext *pb, AVImageFormat *fmt, AVImageInfo *img)
2350 return fmt->img_write(pb, img);