From c9a65ca8c306071b3c359b56a384a1594cd505df Mon Sep 17 00:00:00 2001 From: Fabrice Bellard Date: Mon, 20 May 2002 16:31:13 +0000 Subject: [PATCH] converted to new API Originally committed as revision 547 to svn://svn.ffmpeg.org/ffmpeg/trunk --- libav/Makefile | 11 +- libav/asf.c | 65 ++++++--- libav/au.c | 36 ++++- libav/audio.c | 50 ++++--- libav/avi.h | 5 - libav/avidec.c | 40 ++++-- libav/avienc.c | 23 ++-- libav/avio.c | 8 -- libav/avio.h | 14 -- libav/crc.c | 19 +-- libav/ffm.c | 53 ++++---- libav/gif.c | 24 ++-- libav/grab.c | 35 ++--- libav/img.c | 185 ++++++++++++++++++------- libav/jpeg.c | 42 ++++-- libav/mov.c | 92 ++++++------- libav/raw.c | 361 +++++++++++++++++++++++++------------------------ libav/rm.c | 57 +++++--- libav/swf.c | 37 ++++- libav/wav.c | 56 +++++--- 20 files changed, 709 insertions(+), 504 deletions(-) diff --git a/libav/Makefile b/libav/Makefile index bbd080f693..ecb91e142f 100644 --- a/libav/Makefile +++ b/libav/Makefile @@ -5,10 +5,13 @@ PWD=$(shell pwd) CFLAGS= $(OPTFLAGS) -Wall -g -I.. -I$(SRC_PATH) -I$(SRC_PATH)/libavcodec -DHAVE_AV_CONFIG_H -OBJS= rm.o mpeg.o asf.o avienc.o jpeg.o swf.o wav.o raw.o \ - avidec.o ffm.o \ - avio.o aviobuf.o utils.o \ - file.o img.o au.o gif.o mov.o crc.o +OBJS= utils.o + +# mux and demuxes +OBJS+=mpeg.o mpegts.o ffm.o crc.o img.o raw.o rm.o asf.o \ + avienc.o avidec.o wav.o swf.o au.o gif.o mov.o jpeg.o +# file I/O +OBJS+= avio.o aviobuf.o file.o ifeq ($(CONFIG_GRAB),yes) OBJS+= grab.o audio.o diff --git a/libav/asf.c b/libav/asf.c index 7cb9fca067..93e801bd0c 100644 --- a/libav/asf.c +++ b/libav/asf.c @@ -420,12 +420,7 @@ static int asf_write_header1(AVFormatContext *s, INT64 file_size, INT64 data_chu static int asf_write_header(AVFormatContext *s) { - ASFContext *asf; - - asf = av_mallocz(sizeof(ASFContext)); - if (!asf) - return -1; - s->priv_data = asf; + ASFContext *asf = s->priv_data; asf->packet_size = PACKET_SIZE; asf->nb_packets = 0; @@ -614,8 +609,6 @@ static int asf_write_trailer(AVFormatContext *s) } put_flush_packet(&s->pb); - - av_free(asf); return 0; } @@ -679,9 +672,34 @@ static void get_str16_nolen(ByteIOContext *pb, int len, char *buf, int buf_size) *q = '\0'; } +static int asf_probe(AVProbeData *pd) +{ + GUID g; + const unsigned char *p; + int i; + + /* check file header */ + if (pd->buf_size <= 32) + return 0; + p = pd->buf; + g.v1 = p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24); + p += 4; + g.v2 = p[0] | (p[1] << 8); + p += 2; + g.v3 = p[0] | (p[1] << 8); + p += 2; + for(i=0;i<8;i++) + g.v4[i] = *p++; + + if (!memcmp(&g, &asf_header, sizeof(GUID))) + return AVPROBE_SCORE_MAX; + else + return 0; +} + static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap) { - ASFContext *asf; + ASFContext *asf = s->priv_data; GUID g; ByteIOContext *pb = &s->pb; AVStream *st; @@ -689,11 +707,6 @@ static int asf_read_header(AVFormatContext *s, AVFormatParameters *ap) int size, i, bps; INT64 gsize; - asf = av_mallocz(sizeof(ASFContext)); - if (!asf) - return -1; - s->priv_data = asf; - get_guid(pb, &g); if (memcmp(&g, &asf_header, sizeof(GUID))) goto fail; @@ -1015,11 +1028,22 @@ static int asf_read_close(AVFormatContext *s) return 0; } -AVFormat asf_format = { +AVInputFormat asf_iformat = { + "asf", + "asf format", + sizeof(ASFContext), + asf_probe, + asf_read_header, + asf_read_packet, + asf_read_close, +}; + +AVOutputFormat asf_oformat = { "asf", "asf format", "application/octet-stream", "asf,wmv", + sizeof(ASFContext), #ifdef CONFIG_MP3LAME CODEC_ID_MP3LAME, #else @@ -1029,8 +1053,11 @@ AVFormat asf_format = { asf_write_header, asf_write_packet, asf_write_trailer, - - asf_read_header, - asf_read_packet, - asf_read_close, }; + +int asf_init(void) +{ + av_register_input_format(&asf_iformat); + av_register_output_format(&asf_oformat); + return 0; +} diff --git a/libav/au.c b/libav/au.c index 797f36472e..49447df158 100644 --- a/libav/au.c +++ b/libav/au.c @@ -99,6 +99,18 @@ static int au_write_trailer(AVFormatContext *s) return 0; } +static int au_probe(AVProbeData *p) +{ + /* check file header */ + if (p->buf_size <= 24) + return 0; + if (p->buf[0] == '.' && p->buf[1] == 's' && + p->buf[2] == 'n' && p->buf[3] == 'd') + return AVPROBE_SCORE_MAX; + else + return 0; +} + /* au input */ static int au_read_header(AVFormatContext *s, AVFormatParameters *ap) @@ -175,18 +187,32 @@ static int au_read_close(AVFormatContext *s) return 0; } -AVFormat au_format = { +static AVInputFormat au_iformat = { + "au", + "SUN AU Format", + 0, + au_probe, + au_read_header, + au_read_packet, + au_read_close, +}; + +static AVOutputFormat au_oformat = { "au", "SUN AU Format", "audio/basic", "au", + 0, CODEC_ID_PCM_S16BE, CODEC_ID_NONE, au_write_header, au_write_packet, au_write_trailer, - - au_read_header, - au_read_packet, - au_read_close, }; + +int au_init(void) +{ + av_register_input_format(&au_iformat); + av_register_output_format(&au_oformat); + return 0; +} diff --git a/libav/audio.c b/libav/audio.c index ab9e4757d2..d271ae7ec3 100644 --- a/libav/audio.c +++ b/libav/audio.c @@ -147,21 +147,15 @@ static int audio_close(AudioData *s) /* sound output support */ static int audio_write_header(AVFormatContext *s1) { - AudioData *s; + AudioData *s = s1->priv_data; AVStream *st; int ret; - s = av_mallocz(sizeof(AudioData)); - if (!s) - return -ENOMEM; - s1->priv_data = s; - st = s1->streams[0]; s->sample_rate = st->codec.sample_rate; s->channels = st->codec.channels; ret = audio_open(s, 1); if (ret < 0) { - av_free(s); return -EIO; } else { return 0; @@ -201,7 +195,6 @@ static int audio_write_trailer(AVFormatContext *s1) AudioData *s = s1->priv_data; audio_close(s); - av_free(s); return 0; } @@ -209,31 +202,23 @@ static int audio_write_trailer(AVFormatContext *s1) static int audio_read_header(AVFormatContext *s1, AVFormatParameters *ap) { - AudioData *s; + AudioData *s = s1->priv_data; AVStream *st; int ret; if (!ap || ap->sample_rate <= 0 || ap->channels <= 0) return -1; - s = av_mallocz(sizeof(AudioData)); - if (!s) - return -ENOMEM; - st = av_mallocz(sizeof(AVStream)); + st = av_new_stream(s1, 0); if (!st) { - av_free(s); return -ENOMEM; } - s1->priv_data = s; - s1->nb_streams = 1; - s1->streams[0] = st; s->sample_rate = ap->sample_rate; s->channels = ap->channels; ret = audio_open(s, 0); if (ret < 0) { av_free(st); - av_free(s); return -EIO; } else { /* take real parameters */ @@ -284,15 +269,26 @@ static int audio_read_close(AVFormatContext *s1) AudioData *s = s1->priv_data; audio_close(s); - av_free(s); return 0; } -AVFormat audio_device_format = { +AVInputFormat audio_in_format = { + "audio_device", + "audio grab and output", + sizeof(AudioData), + NULL, + audio_read_header, + audio_read_packet, + audio_read_close, + flags: AVFMT_NOFILE, +}; + +AVOutputFormat audio_out_format = { "audio_device", "audio grab and output", "", "", + sizeof(AudioData), /* XXX: we make the assumption that the soundcard accepts this format */ /* XXX: find better solution with "preinit" method, needed also in other formats */ @@ -305,10 +301,12 @@ AVFormat audio_device_format = { audio_write_header, audio_write_packet, audio_write_trailer, - - audio_read_header, - audio_read_packet, - audio_read_close, - NULL, - AVFMT_NOFILE, + flags: AVFMT_NOFILE, }; + +int audio_init(void) +{ + av_register_input_format(&audio_in_format); + av_register_output_format(&audio_out_format); + return 0; +} diff --git a/libav/avi.h b/libav/avi.h index 4606089fe0..043b622635 100644 --- a/libav/avi.h +++ b/libav/avi.h @@ -23,8 +23,3 @@ extern CodecTag codec_wav_tags[]; unsigned int codec_get_tag(const CodecTag *tags, int id); int codec_get_id(const CodecTag *tags, unsigned int tag); - -/* avidec.c */ -int avi_read_header(AVFormatContext *s, AVFormatParameters *ap); -int avi_read_packet(AVFormatContext *s, AVPacket *pkt); -int avi_read_close(AVFormatContext *s); diff --git a/libav/avidec.c b/libav/avidec.c index 4af2d661b9..1ede7b8f3a 100644 --- a/libav/avidec.c +++ b/libav/avidec.c @@ -47,19 +47,13 @@ void print_tag(const char *str, unsigned int tag, int size) int avi_read_header(AVFormatContext *s, AVFormatParameters *ap) { - AVIContext *avi; + AVIContext *avi = s->priv_data; ByteIOContext *pb = &s->pb; UINT32 tag, tag1; int codec_type, stream_index, size, frame_period, bit_rate; int i, bps; AVStream *st; - avi = av_malloc(sizeof(AVIContext)); - if (!avi) - return -1; - memset(avi, 0, sizeof(AVIContext)); - s->priv_data = avi; - /* check RIFF header */ tag = get_le32(pb); @@ -246,7 +240,35 @@ int avi_read_packet(AVFormatContext *s, AVPacket *pkt) int avi_read_close(AVFormatContext *s) { - AVIContext *avi = s->priv_data; - av_free(avi); + return 0; +} + +static int avi_probe(AVProbeData *p) +{ + /* check file header */ + if (p->buf_size <= 32) + return 0; + if (p->buf[0] == 'R' && p->buf[1] == 'I' && + p->buf[2] == 'F' && p->buf[3] == 'F' && + p->buf[8] == 'A' && p->buf[9] == 'V' && + p->buf[10] == 'I' && p->buf[11] == ' ') + return AVPROBE_SCORE_MAX; + else + return 0; +} + +static AVInputFormat avi_iformat = { + "avi", + "avi format", + sizeof(AVIContext), + avi_probe, + avi_read_header, + avi_read_packet, + avi_read_close, +}; + +int avidec_init(void) +{ + av_register_input_format(&avi_iformat); return 0; } diff --git a/libav/avienc.c b/libav/avienc.c index 6d2b0ab444..552954107e 100644 --- a/libav/avienc.c +++ b/libav/avienc.c @@ -143,18 +143,12 @@ void parse_specific_params(AVCodecContext *stream, int *au_byterate, int *au_ssi static int avi_write_header(AVFormatContext *s) { - AVIContext *avi; + AVIContext *avi = s->priv_data; ByteIOContext *pb = &s->pb; int bitrate, n, i, nb_frames, au_byterate, au_ssize, au_scale; AVCodecContext *stream, *video_enc; offset_t list1, list2, strh, strf; - avi = av_malloc(sizeof(AVIContext)); - if (!avi) - return -1; - memset(avi, 0, sizeof(AVIContext)); - s->priv_data = avi; - put_tag(pb, "RIFF"); put_le32(pb, 0); /* file length */ put_tag(pb, "AVI "); @@ -388,23 +382,24 @@ static int avi_write_trailer(AVFormatContext *s) url_fseek(pb, file_size, SEEK_SET); } put_flush_packet(pb); - - av_free(avi); return 0; } -AVFormat avi_format = { +static AVOutputFormat avi_oformat = { "avi", "avi format", "video/x-msvideo", "avi", + sizeof(AVIContext), CODEC_ID_MP2, CODEC_ID_MSMPEG4, avi_write_header, avi_write_packet, avi_write_trailer, - - avi_read_header, - avi_read_packet, - avi_read_close, }; + +int avienc_init(void) +{ + av_register_output_format(&avi_oformat); + return 0; +} diff --git a/libav/avio.c b/libav/avio.c index 7f12571061..10af760098 100644 --- a/libav/avio.c +++ b/libav/avio.c @@ -105,14 +105,6 @@ offset_t url_seek(URLContext *h, offset_t pos, int whence) return ret; } -int url_getformat(URLContext *h, URLFormat *f) -{ - memset(f, 0, sizeof(*f)); - if (!h->prot->url_getformat) - return -ENODATA; - return h->prot->url_getformat(h, f); -} - int url_close(URLContext *h) { int ret; diff --git a/libav/avio.h b/libav/avio.h index 03b12afd61..36263167a8 100644 --- a/libav/avio.h +++ b/libav/avio.h @@ -12,16 +12,6 @@ struct URLContext { void *priv_data; }; -typedef struct URLFormat { - char format_name[32]; - int sample_rate; - int frame_rate; - int channels; - int height; - int width; - enum PixelFormat pix_fmt; -} URLFormat; - typedef struct URLContext URLContext; typedef struct URLPollEntry { @@ -36,7 +26,6 @@ int url_open(URLContext **h, const char *filename, int flags); int url_read(URLContext *h, unsigned char *buf, int size); int url_write(URLContext *h, unsigned char *buf, int size); offset_t url_seek(URLContext *h, offset_t pos, int whence); -int url_getformat(URLContext *h, URLFormat *f); int url_close(URLContext *h); int url_exist(const char *filename); offset_t url_filesize(URLContext *h); @@ -50,9 +39,6 @@ typedef struct URLProtocol { int (*url_write)(URLContext *h, unsigned char *buf, int size); offset_t (*url_seek)(URLContext *h, offset_t pos, int whence); int (*url_close)(URLContext *h); - /* get precise information about the format, if available. return - -ENODATA if not available */ - int (*url_getformat)(URLContext *h, URLFormat *f); struct URLProtocol *next; } URLProtocol; diff --git a/libav/crc.c b/libav/crc.c index b1e6d0bea2..159fb25ff8 100644 --- a/libav/crc.c +++ b/libav/crc.c @@ -61,15 +61,10 @@ typedef struct CRCState { UINT32 crcval; } CRCState; -/* simple formats */ static int crc_write_header(struct AVFormatContext *s) { - CRCState *crc; - crc = av_malloc(sizeof(CRCState)); - if (!crc) - return -1; - s->priv_data = crc; - + CRCState *crc = s->priv_data; + /* init CRC */ crc->crcval = adler32(0, NULL, 0); @@ -93,18 +88,24 @@ static int crc_write_trailer(struct AVFormatContext *s) snprintf(buf, sizeof(buf), "CRC=%08x\n", crc->crcval); put_buffer(&s->pb, buf, strlen(buf)); put_flush_packet(&s->pb); - av_free(crc); return 0; } -AVFormat crc_format = { +AVOutputFormat crc_format = { "crc", "crc testing format", NULL, "", + sizeof(CRCState), CODEC_ID_PCM_S16LE, CODEC_ID_RAWVIDEO, crc_write_header, crc_write_packet, crc_write_trailer, }; + +int crc_init(void) +{ + av_register_output_format(&crc_format); + return 0; +} diff --git a/libav/ffm.c b/libav/ffm.c index a9892a68a6..8d05ca9c4a 100644 --- a/libav/ffm.c +++ b/libav/ffm.c @@ -51,6 +51,9 @@ typedef struct FFMContext { UINT8 packet[1]; /* must be last */ } FFMContext; +/* disable pts hack for testing */ +int ffm_nopts = 0; + static void flush_packet(AVFormatContext *s) { FFMContext *ffm = s->priv_data; @@ -112,18 +115,13 @@ static void ffm_write_data(AVFormatContext *s, static int ffm_write_header(AVFormatContext *s) { + FFMContext *ffm = s->priv_data; AVStream *st; FFMStream *fst; - FFMContext *ffm; ByteIOContext *pb = &s->pb; AVCodecContext *codec; int bit_rate, i; - ffm = av_mallocz(sizeof(FFMContext) + FFM_PACKET_SIZE); - if (!ffm) - return -1; - - s->priv_data = ffm; ffm->packet_size = FFM_PACKET_SIZE; /* header */ @@ -177,7 +175,10 @@ static int ffm_write_header(AVFormatContext *s) abort(); } /* hack to have real time */ - fst->pts = gettime(); + if (ffm_nopts) + fst->pts = 0; + else + fst->pts = gettime(); } /* flush until end of block reached */ @@ -200,7 +201,6 @@ static int ffm_write_header(AVFormatContext *s) fst = st->priv_data; av_free(fst); } - av_free(ffm); return -1; } @@ -252,7 +252,6 @@ static int ffm_write_trailer(AVFormatContext *s) for(i=0;inb_streams;i++) av_free(s->streams[i]->priv_data); - av_free(ffm); return 0; } @@ -342,20 +341,14 @@ static int ffm_read_data(AVFormatContext *s, static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap) { + FFMContext *ffm = s->priv_data; AVStream *st; FFMStream *fst; - FFMContext *ffm; ByteIOContext *pb = &s->pb; AVCodecContext *codec; int i; UINT32 tag; - ffm = av_mallocz(sizeof(FFMContext) + FFM_PACKET_SIZE); - if (!ffm) - return -1; - - s->priv_data = ffm; - /* header */ tag = get_le32(pb); if (tag != MKTAG('F', 'F', 'M', '1')) @@ -436,8 +429,6 @@ static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap) av_free(st); } } - if (ffm) - av_free(ffm); return -1; } @@ -619,19 +610,35 @@ static int ffm_read_close(AVFormatContext *s) return 0; } -AVFormat ffm_format = { +AVInputFormat ffm_iformat = { + "ffm", + "ffm format", + sizeof(FFMContext), + NULL, + ffm_read_header, + ffm_read_packet, + ffm_read_close, + ffm_seek, + extensions: "ffm", +}; + +AVOutputFormat ffm_oformat = { "ffm", "ffm format", "", "ffm", + sizeof(FFMContext) + FFM_PACKET_SIZE, /* not really used */ CODEC_ID_MP2, CODEC_ID_MPEG1VIDEO, ffm_write_header, ffm_write_packet, ffm_write_trailer, - ffm_read_header, - ffm_read_packet, - ffm_read_close, - ffm_seek, }; + +int ffm_init(void) +{ + av_register_input_format(&ffm_iformat); + av_register_output_format(&ffm_oformat); + return 0; +} diff --git a/libav/gif.c b/libav/gif.c index 4aa1ba0b82..42874e033e 100644 --- a/libav/gif.c +++ b/libav/gif.c @@ -192,7 +192,7 @@ typedef struct { static int gif_write_header(AVFormatContext *s) { - GIFContext *gif; + GIFContext *gif = s->priv_data; ByteIOContext *pb = &s->pb; AVCodecContext *enc, *video_enc; int i, width, height, rate; @@ -201,12 +201,6 @@ static int gif_write_header(AVFormatContext *s) if(s->nb_streams > 1) return -1; */ - - gif = av_malloc(sizeof(GIFContext)); - if (!gif) - return -1; - s->priv_data = gif; - gif->time = 0; gif->file_time = 0; @@ -376,28 +370,28 @@ static int gif_write_packet(AVFormatContext *s, int stream_index, static int gif_write_trailer(AVFormatContext *s) { - GIFContext *gif = s->priv_data; ByteIOContext *pb = &s->pb; put_byte(pb, 0x3b); put_flush_packet(&s->pb); - - av_free(gif); return 0; } -AVFormat gif_format = { +static AVOutputFormat gif_oformat = { "gif", "GIF Animation", "image/gif", "gif", + sizeof(GIFContext), CODEC_ID_NONE, CODEC_ID_RAWVIDEO, gif_write_header, gif_write_packet, gif_write_trailer, - - NULL, /* read_header */ - NULL, /* read_packet */ - NULL, /* read_close */ }; + +int gif_init(void) +{ + av_register_output_format(&gif_oformat); + return 0; +} diff --git a/libav/grab.c b/libav/grab.c index e456468c4e..48145c8b4f 100644 --- a/libav/grab.c +++ b/libav/grab.c @@ -48,7 +48,7 @@ static int gb_frame = 0; static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap) { - VideoData *s; + VideoData *s = s1->priv_data; AVStream *st; int width, height; int video_fd, frame_size; @@ -62,17 +62,9 @@ static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap) height = ap->height; frame_rate = ap->frame_rate; - s = av_mallocz(sizeof(VideoData)); - if (!s) - return -ENOMEM; - st = av_mallocz(sizeof(AVStream)); - if (!st) { - av_free(s); + st = av_new_stream(s1, 0); + if (!st) return -ENOMEM; - } - s1->priv_data = s; - s1->nb_streams = 1; - s1->streams[0] = st; s->width = width; s->height = height; @@ -232,7 +224,6 @@ static int grab_read_header(AVFormatContext *s1, AVFormatParameters *ap) if (video_fd >= 0) close(video_fd); av_free(st); - av_free(s); return -EIO; } @@ -327,24 +318,22 @@ static int grab_read_close(AVFormatContext *s1) ioctl(s->fd, VIDIOCSAUDIO, &audio_saved); close(s->fd); - av_free(s); return 0; } -AVFormat video_grab_device_format = { +AVInputFormat video_grab_device_format = { "video_grab_device", "video grab", - "", - "", - CODEC_ID_NONE, - CODEC_ID_NONE, + sizeof(VideoData), NULL, - NULL, - NULL, - grab_read_header, grab_read_packet, grab_read_close, - NULL, - AVFMT_NOFILE, + flags: AVFMT_NOFILE, }; + +int video_grab_init(void) +{ + av_register_input_format(&video_grab_device_format); + return 0; +} diff --git a/libav/img.c b/libav/img.c index 3ac8b52bfc..dc3816bc92 100644 --- a/libav/img.c +++ b/libav/img.c @@ -1,6 +1,6 @@ /* * Image format - * Copyright (c) 2000, 2001 Gerard Lantau. + * Copyright (c) 2000, 2001, 2002 Gerard Lantau. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -18,6 +18,21 @@ */ #include "avformat.h" +extern AVInputFormat pgm_iformat; +extern AVOutputFormat pgm_oformat; +extern AVInputFormat pgmyuv_iformat; +extern AVOutputFormat pgmyuv_oformat; +extern AVInputFormat ppm_iformat; +extern AVOutputFormat ppm_oformat; +extern AVInputFormat imgyuv_iformat; +extern AVOutputFormat imgyuv_oformat; +extern AVInputFormat pgmpipe_iformat; +extern AVOutputFormat pgmpipe_oformat; +extern AVInputFormat pgmyuvpipe_iformat; +extern AVOutputFormat pgmyuvpipe_oformat; +extern AVInputFormat ppmpipe_iformat; +extern AVOutputFormat ppmpipe_oformat; + #define IMGFMT_YUV 1 #define IMGFMT_PGMYUV 2 #define IMGFMT_PGM 3 @@ -248,46 +263,38 @@ static int infer_size(int *width_ptr, int *height_ptr, int size) static int img_read_header(AVFormatContext *s1, AVFormatParameters *ap) { - VideoData *s; + VideoData *s = s1->priv_data; int i, h; char buf[1024]; char buf1[32]; ByteIOContext pb1, *f = &pb1; AVStream *st; - s = av_malloc(sizeof(VideoData)); - if (!s) - return -ENOMEM; - - s1->priv_data = s; - - s1->nb_streams = 1; - st = av_mallocz(sizeof(AVStream)); + st = av_new_stream(s1, 0); if (!st) { av_free(s); return -ENOMEM; } - s1->streams[0] = st; - + strcpy(s->path, s1->filename); s->img_number = 0; /* find format */ - if (s1->format->flags & AVFMT_NOFILE) + if (s1->iformat->flags & AVFMT_NOFILE) s->is_pipe = 0; else s->is_pipe = 1; - if (s1->format == &pgmyuvpipe_format || - s1->format == &pgmyuv_format) + if (s1->iformat == &pgmyuvpipe_iformat || + s1->iformat == &pgmyuv_iformat) s->img_fmt = IMGFMT_PGMYUV; - else if (s1->format == &pgmpipe_format || - s1->format == &pgm_format) + else if (s1->iformat == &pgmpipe_iformat || + s1->iformat == &pgm_iformat) s->img_fmt = IMGFMT_PGM; - else if (s1->format == &imgyuv_format) + else if (s1->iformat == &imgyuv_iformat) s->img_fmt = IMGFMT_YUV; - else if (s1->format == &ppmpipe_format || - s1->format == &ppm_format) + else if (s1->iformat == &ppmpipe_iformat || + s1->iformat == &ppm_iformat) s->img_fmt = IMGFMT_PPM; else goto fail; @@ -378,8 +385,6 @@ static int img_read_header(AVFormatContext *s1, AVFormatParameters *ap) static int img_read_close(AVFormatContext *s1) { - VideoData *s = s1->priv_data; - av_free(s); return 0; } @@ -479,31 +484,27 @@ static int yuv_save(AVPicture *picture, int width, int height, const char *filen static int img_write_header(AVFormatContext *s) { - VideoData *img; + VideoData *img = s->priv_data; - img = av_mallocz(sizeof(VideoData)); - if (!img) - return -1; - s->priv_data = img; img->img_number = 1; strcpy(img->path, s->filename); /* find format */ - if (s->format->flags & AVFMT_NOFILE) + if (s->oformat->flags & AVFMT_NOFILE) img->is_pipe = 0; else img->is_pipe = 1; - if (s->format == &pgmyuvpipe_format || - s->format == &pgmyuv_format) { + if (s->oformat == &pgmyuvpipe_oformat || + s->oformat == &pgmyuv_oformat) { img->img_fmt = IMGFMT_PGMYUV; - } else if (s->format == &pgmpipe_format || - s->format == &pgm_format) { + } else if (s->oformat == &pgmpipe_oformat || + s->oformat == &pgm_oformat) { img->img_fmt = IMGFMT_PGM; - } else if (s->format == &imgyuv_format) { + } else if (s->oformat == &imgyuv_oformat) { img->img_fmt = IMGFMT_YUV; - } else if (s->format == &ppmpipe_format || - s->format == &ppm_format) { + } else if (s->oformat == &ppmpipe_oformat || + s->oformat == &ppm_oformat) { img->img_fmt = IMGFMT_PPM; } else { goto fail; @@ -590,22 +591,41 @@ static int img_write_packet(AVFormatContext *s, int stream_index, static int img_write_trailer(AVFormatContext *s) { - VideoData *img = s->priv_data; - av_free(img); return 0; } -AVFormat pgm_format = { +AVInputFormat pgm_iformat = { + "pgm", + "pgm image format", + sizeof(VideoData), + NULL, + img_read_header, + img_read_packet, + img_read_close, + NULL, + AVFMT_NOFILE | AVFMT_NEEDNUMBER, + extensions: "pgm", +}; + +AVOutputFormat pgm_oformat = { "pgm", "pgm image format", "", "pgm", + sizeof(VideoData), CODEC_ID_NONE, CODEC_ID_RAWVIDEO, img_write_header, img_write_packet, img_write_trailer, + AVFMT_NOFILE | AVFMT_NEEDNUMBER, +}; +AVInputFormat pgmyuv_iformat = { + "pgmyuv", + "pgm with YUV content image format", + sizeof(VideoData), + NULL, /* no probe */ img_read_header, img_read_packet, img_read_close, @@ -613,107 +633,170 @@ AVFormat pgm_format = { AVFMT_NOFILE | AVFMT_NEEDNUMBER, }; -AVFormat pgmyuv_format = { +AVOutputFormat pgmyuv_oformat = { "pgmyuv", "pgm with YUV content image format", "", "pgm", + sizeof(VideoData), CODEC_ID_NONE, CODEC_ID_RAWVIDEO, img_write_header, img_write_packet, img_write_trailer, + AVFMT_NOFILE | AVFMT_NEEDNUMBER, +}; +AVInputFormat ppm_iformat = { + "ppm", + "ppm image format", + sizeof(VideoData), + NULL, img_read_header, img_read_packet, img_read_close, NULL, - AVFMT_NOFILE | AVFMT_NEEDNUMBER, + AVFMT_NOFILE | AVFMT_NEEDNUMBER | AVFMT_RGB24, + extensions: "ppm", }; -AVFormat ppm_format = { +AVOutputFormat ppm_oformat = { "ppm", "ppm image format", "", "ppm", + sizeof(VideoData), CODEC_ID_NONE, CODEC_ID_RAWVIDEO, img_write_header, img_write_packet, img_write_trailer, + AVFMT_NOFILE | AVFMT_NEEDNUMBER | AVFMT_RGB24, +}; +AVInputFormat imgyuv_iformat = { + ".Y.U.V", + ".Y.U.V format", + sizeof(VideoData), + NULL, img_read_header, img_read_packet, img_read_close, NULL, AVFMT_NOFILE | AVFMT_NEEDNUMBER, + extensions: "Y", }; -AVFormat imgyuv_format = { +AVOutputFormat imgyuv_oformat = { ".Y.U.V", ".Y.U.V format", "", "Y", + sizeof(VideoData), CODEC_ID_NONE, CODEC_ID_RAWVIDEO, img_write_header, img_write_packet, img_write_trailer, + AVFMT_NOFILE | AVFMT_NEEDNUMBER, +}; +AVInputFormat pgmpipe_iformat = { + "pgmpipe", + "PGM pipe format", + sizeof(VideoData), + NULL, /* no probe */ img_read_header, img_read_packet, img_read_close, NULL, - AVFMT_NOFILE | AVFMT_NEEDNUMBER, }; -AVFormat pgmpipe_format = { +AVOutputFormat pgmpipe_oformat = { "pgmpipe", "PGM pipe format", "", "pgm", + sizeof(VideoData), CODEC_ID_NONE, CODEC_ID_RAWVIDEO, img_write_header, img_write_packet, img_write_trailer, +}; +AVInputFormat pgmyuvpipe_iformat = { + "pgmyuvpipe", + "PGM YUV pipe format", + sizeof(VideoData), + NULL, /* no probe */ img_read_header, img_read_packet, img_read_close, NULL, }; -AVFormat pgmyuvpipe_format = { +AVOutputFormat pgmyuvpipe_oformat = { "pgmyuvpipe", "PGM YUV pipe format", "", "pgm", + sizeof(VideoData), CODEC_ID_NONE, CODEC_ID_RAWVIDEO, img_write_header, img_write_packet, img_write_trailer, +}; +AVInputFormat ppmpipe_iformat = { + "ppmpipe", + "PPM pipe format", + sizeof(VideoData), + NULL, /* no probe */ img_read_header, img_read_packet, img_read_close, NULL, + flags: AVFMT_RGB24, }; -AVFormat ppmpipe_format = { +AVOutputFormat ppmpipe_oformat = { "ppmpipe", "PPM pipe format", "", "ppm", + sizeof(VideoData), CODEC_ID_NONE, CODEC_ID_RAWVIDEO, img_write_header, img_write_packet, img_write_trailer, - - img_read_header, - img_read_packet, - img_read_close, - NULL, + flags: AVFMT_RGB24, }; + + +int img_init(void) +{ + av_register_input_format(&pgm_iformat); + av_register_output_format(&pgm_oformat); + + av_register_input_format(&pgmyuv_iformat); + av_register_output_format(&pgmyuv_oformat); + + av_register_input_format(&ppm_iformat); + av_register_output_format(&ppm_oformat); + + av_register_input_format(&imgyuv_iformat); + av_register_output_format(&imgyuv_oformat); + + av_register_input_format(&pgmpipe_iformat); + av_register_output_format(&pgmpipe_oformat); + + av_register_input_format(&pgmyuvpipe_iformat); + av_register_output_format(&pgmyuvpipe_oformat); + + av_register_input_format(&ppmpipe_iformat); + av_register_output_format(&ppmpipe_oformat); + return 0; +} diff --git a/libav/jpeg.c b/libav/jpeg.c index 732898252b..a017cbffb0 100644 --- a/libav/jpeg.c +++ b/libav/jpeg.c @@ -52,11 +52,12 @@ static int mpjpeg_write_trailer(AVFormatContext *s) return 0; } -AVFormat mpjpeg_format = { +static AVOutputFormat mpjpeg_format = { "mpjpeg", "Mime multipart JPEG format", "multipart/x-mixed-replace;boundary=" BOUNDARY_TAG, "mjpg", + 0, CODEC_ID_NONE, CODEC_ID_MJPEG, mpjpeg_write_header, @@ -86,11 +87,12 @@ static int single_jpeg_write_trailer(AVFormatContext *s) return 0; } -AVFormat single_jpeg_format = { +static AVOutputFormat single_jpeg_format = { "singlejpeg", "single JPEG image", "image/jpeg", "jpg,jpeg", + 0, CODEC_ID_NONE, CODEC_ID_MJPEG, single_jpeg_write_header, @@ -114,7 +116,7 @@ static int jpeg_write_header(AVFormatContext *s1) if (!s) return -1; s1->priv_data = s; - nstrcpy(s->path, sizeof(s->path), s1->filename); + pstrcpy(s->path, sizeof(s->path), s1->filename); s->img_number = 1; return 0; } @@ -162,7 +164,7 @@ static int jpeg_read_header(AVFormatContext *s1, AVFormatParameters *ap) if (!s) return -1; s1->priv_data = s; - nstrcpy(s->path, sizeof(s->path), s1->filename); + pstrcpy(s->path, sizeof(s->path), s1->filename); s1->nb_streams = 1; st = av_mallocz(sizeof(AVStream)); @@ -231,20 +233,38 @@ static int jpeg_read_close(AVFormatContext *s1) return 0; } -AVFormat jpeg_format = { +static AVInputFormat jpeg_iformat = { + "jpeg", + "JPEG image", + sizeof(JpegContext), + NULL, + jpeg_read_header, + jpeg_read_packet, + jpeg_read_close, + NULL, + flags: AVFMT_NOFILE | AVFMT_NEEDNUMBER, + extensions: "jpg,jpeg", +}; + +static AVOutputFormat jpeg_oformat = { "jpeg", "JPEG image", "image/jpeg", "jpg,jpeg", + sizeof(JpegContext), CODEC_ID_NONE, CODEC_ID_MJPEG, jpeg_write_header, jpeg_write_packet, jpeg_write_trailer, - - jpeg_read_header, - jpeg_read_packet, - jpeg_read_close, - NULL, - AVFMT_NOFILE | AVFMT_NEEDNUMBER, + flags: AVFMT_NOFILE | AVFMT_NEEDNUMBER, }; + +int jpeg_init(void) +{ + av_register_output_format(&mpjpeg_format); + av_register_output_format(&single_jpeg_format); + av_register_input_format(&jpeg_iformat); + av_register_output_format(&jpeg_oformat); + return 0; +} diff --git a/libav/mov.c b/libav/mov.c index 89732c0003..7f872a6b0d 100644 --- a/libav/mov.c +++ b/libav/mov.c @@ -44,7 +44,7 @@ * QuickTime is a trademark of Apple (AFAIK :)) */ -#define DEBUG +//#define DEBUG #ifdef DEBUG /* @@ -394,7 +394,7 @@ static int parse_hdlr(const MOVParseTableEntry *parse_table, ByteIOContext *pb, { MOVContext *c; int len; - char *buf, ch; + char *buf; UINT32 type; AVStream *st; UINT32 ctype; @@ -453,21 +453,23 @@ static int parse_hdlr(const MOVParseTableEntry *parse_table, ByteIOContext *pb, return 0; /* nothing left to read */ /* XXX: MP4 uses a C string, not a pascal one */ /* component name */ - if(c->mp4) { + len = get_byte(pb); + /* XXX: use a better heuristic */ + if(len < 32) { + /* assume that it is a Pascal like string */ + buf = av_malloc(len+1); + get_buffer(pb, buf, len); + buf[len] = '\0'; #ifdef DEBUG - puts("MP4!!!"); + printf("**buf='%s'\n", buf); #endif - while ((ch = get_byte(pb))); + av_free(buf); } else { - len = get_byte(pb); - if(len) { - buf = av_malloc(len+1); - get_buffer(pb, buf, len); - buf[len] = '\0'; -#ifdef DEBUG - puts(buf); -#endif - av_free(buf); + /* MP4 string */ + for(;;) { + if (len == 0) + break; + len = get_byte(pb); } } @@ -763,21 +765,34 @@ static void mov_free_stream_context(MOVStreamContext *sc) } } +/* XXX: is it suffisant ? */ +static int mov_probe(AVProbeData *p) +{ + /* check file header */ + if (p->buf_size <= 12) + return 0; + if ((p->buf[4] == 'm' && p->buf[5] == 'o' && + p->buf[6] == 'o' && p->buf[7] == 'v') || + (p->buf[4] == 'm' && p->buf[5] == 'd' && + p->buf[6] == 'a' && p->buf[7] == 't')) + return AVPROBE_SCORE_MAX; + else + return 0; +} + static int mov_read_header(AVFormatContext *s, AVFormatParameters *ap) { - MOVContext *mov; + MOVContext *mov = s->priv_data; ByteIOContext *pb = &s->pb; int i, j, nb, err; INT64 size; - mov = av_mallocz(sizeof(MOVContext)); - if (!mov) - return -1; - s->priv_data = mov; - mov->fc = s; - if(s->format->name[1] == 'p') +#if 0 + /* XXX: I think we should auto detect */ + if(s->iformat->name[1] == 'p') mov->mp4 = 1; +#endif if(!url_is_streamed(pb)) /* .mov and .mp4 aren't streamable anyway (only progressive download if moov is before mdat) */ size = url_filesize(url_fileno(pb)); else @@ -916,38 +931,21 @@ static int mov_read_close(AVFormatContext *s) mov_free_stream_context(mov->streams[i]); for(i=0; inb_streams; i++) av_free(s->streams[i]); - av_free(mov); return 0; } -AVFormat mov_format = { - "mov", - "QuickTime format", - "video/quicktime", +static AVInputFormat mov_iformat = { "mov", - CODEC_ID_MP2, - CODEC_ID_MJPEG, - NULL, - NULL, - NULL, - + "QuickTime/MPEG4 format", + sizeof(MOVContext), + mov_probe, mov_read_header, mov_read_packet, mov_read_close, }; -AVFormat mp4_format = { - "mp4", - "MPEG4 file format", - "video/mpeg4", - "mp4", - CODEC_ID_MP2, - CODEC_ID_MJPEG, - NULL, - NULL, - NULL, - - mov_read_header, - mov_read_packet, - mov_read_close, -}; +int mov_init(void) +{ + av_register_input_format(&mov_iformat); + return 0; +} diff --git a/libav/raw.c b/libav/raw.c index 5608287e65..40ef40308a 100644 --- a/libav/raw.c +++ b/libav/raw.c @@ -43,27 +43,20 @@ static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap) { AVStream *st; + int id; - st = av_malloc(sizeof(AVStream)); + st = av_new_stream(s, 0); if (!st) - return -1; - s->nb_streams = 1; - s->streams[0] = st; - - st->id = 0; - + return AVERROR_NOMEM; if (ap) { - if (s->format->audio_codec != CODEC_ID_NONE) { - st->codec.codec_type = CODEC_TYPE_AUDIO; - st->codec.codec_id = s->format->audio_codec; - } else if (s->format->video_codec != CODEC_ID_NONE) { + id = s->iformat->value; + if (id == CODEC_ID_RAWVIDEO) { st->codec.codec_type = CODEC_TYPE_VIDEO; - st->codec.codec_id = s->format->video_codec; } else { - av_free(st); - return -1; + st->codec.codec_type = CODEC_TYPE_AUDIO; } - + st->codec.codec_id = id; + switch(st->codec.codec_type) { case CODEC_TYPE_AUDIO: st->codec.sample_rate = ap->sample_rate; @@ -116,13 +109,9 @@ static int mp3_read_header(AVFormatContext *s, { AVStream *st; - st = av_malloc(sizeof(AVStream)); + st = av_new_stream(s, 0); if (!st) - return -1; - s->nb_streams = 1; - s->streams[0] = st; - - st->id = 0; + return AVERROR_NOMEM; st->codec.codec_type = CODEC_TYPE_AUDIO; st->codec.codec_id = CODEC_ID_MP2; @@ -136,14 +125,12 @@ static int video_read_header(AVFormatContext *s, { AVStream *st; - st = av_mallocz(sizeof(AVStream)); + st = av_new_stream(s, 0); if (!st) - return -1; - s->nb_streams = 1; - s->streams[0] = st; + return AVERROR_NOMEM; st->codec.codec_type = CODEC_TYPE_VIDEO; - st->codec.codec_id = s->format->video_codec; + st->codec.codec_id = s->iformat->value; /* for mjpeg, specify frame rate */ if (st->codec.codec_id == CODEC_ID_MJPEG) { if (ap) { @@ -155,227 +142,206 @@ static int video_read_header(AVFormatContext *s, return 0; } -AVFormat mp2_format = { - "mp2", +#define SEQ_START_CODE 0x000001b3 +#define GOP_START_CODE 0x000001b8 +#define PICTURE_START_CODE 0x00000100 + +/* XXX: improve that by looking at several start codes */ +static int mpegvideo_probe(AVProbeData *p) +{ + int code, c, i; + code = 0xff; + + /* we search the first start code. If it is a sequence, gop or + picture start code then we decide it is an mpeg video + stream. We do not send highest value to give a chance to mpegts */ + for(i=0;ibuf_size;i++) { + c = p->buf[i]; + code = (code << 8) | c; + if ((code & 0xffffff00) == 0x100) { + if (code == SEQ_START_CODE || + code == GOP_START_CODE || + code == PICTURE_START_CODE) + return AVPROBE_SCORE_MAX - 1; + else + return 0; + } + } + return 0; +} + +AVInputFormat mp3_iformat = { + "mp3", "MPEG audio", + 0, + NULL, + mp3_read_header, + raw_read_packet, + raw_read_close, + extensions: "mp2,mp3", /* XXX: use probe */ +}; + +AVOutputFormat mp2_oformat = { + "mp2", + "MPEG audio layer 2", "audio/x-mpeg", "mp2,mp3", + 0, CODEC_ID_MP2, 0, raw_write_header, raw_write_packet, raw_write_trailer, +}; - mp3_read_header, + +AVInputFormat ac3_iformat = { + "ac3", + "raw ac3", + 0, + NULL, + raw_read_header, raw_read_packet, raw_read_close, + extensions: "ac3", + value: CODEC_ID_AC3, }; -AVFormat ac3_format = { +AVOutputFormat ac3_oformat = { "ac3", "raw ac3", "audio/x-ac3", "ac3", + 0, CODEC_ID_AC3, 0, raw_write_header, raw_write_packet, raw_write_trailer, - raw_read_header, - raw_read_packet, - raw_read_close, }; -AVFormat h263_format = { +AVOutputFormat h263_oformat = { "h263", "raw h263", "video/x-h263", "h263", 0, + 0, CODEC_ID_H263, raw_write_header, raw_write_packet, raw_write_trailer, +}; + +AVInputFormat mpegvideo_iformat = { + "mpegvideo", + "MPEG video", + 0, + mpegvideo_probe, video_read_header, raw_read_packet, raw_read_close, + value: CODEC_ID_MPEG1VIDEO, }; -AVFormat mpeg1video_format = { - "mpegvideo", +AVOutputFormat mpeg1video_oformat = { + "mpeg1video", "MPEG video", "video/x-mpeg", "mpg,mpeg", 0, + 0, CODEC_ID_MPEG1VIDEO, raw_write_header, raw_write_packet, raw_write_trailer, - video_read_header, - raw_read_packet, - raw_read_close, }; -AVFormat mjpeg_format = { +AVInputFormat mjpeg_iformat = { "mjpeg", "MJPEG video", - "video/x-mjpeg", - "mjpg,mjpeg", 0, - CODEC_ID_MJPEG, - raw_write_header, - raw_write_packet, - raw_write_trailer, + NULL, video_read_header, raw_read_packet, raw_read_close, + extensions: "mjpg,mjpeg", + value: CODEC_ID_MJPEG, }; -/* pcm formats */ - -AVFormat pcm_s16le_format = { - "s16le", - "pcm signed 16 bit little endian format", - NULL, -#ifdef WORDS_BIGENDIAN - "", -#else - "sw", -#endif - CODEC_ID_PCM_S16LE, +AVOutputFormat mjpeg_oformat = { + "mjpeg", + "MJPEG video", + "video/x-mjpeg", + "mjpg,mjpeg", 0, - raw_write_header, - raw_write_packet, - raw_write_trailer, - - raw_read_header, - raw_read_packet, - raw_read_close, -}; - -AVFormat pcm_s16be_format = { - "s16be", - "pcm signed 16 bit big endian format", - NULL, -#ifdef WORDS_BIGENDIAN - "sw", -#else - "", -#endif - CODEC_ID_PCM_S16BE, 0, + CODEC_ID_MJPEG, raw_write_header, raw_write_packet, raw_write_trailer, - - raw_read_header, - raw_read_packet, - raw_read_close, }; -AVFormat pcm_u16le_format = { - "u16le", - "pcm unsigned 16 bit little endian format", - NULL, -#ifdef WORDS_BIGENDIAN - "", -#else - "uw", -#endif - CODEC_ID_PCM_U16LE, - 0, - raw_write_header, - raw_write_packet, - raw_write_trailer, +/* pcm formats */ - raw_read_header, - raw_read_packet, - raw_read_close, +#define PCMDEF(name, long_name, ext, codec) \ +AVInputFormat pcm_ ## name ## _iformat = {\ + #name,\ + long_name,\ + 0,\ + NULL,\ + raw_read_header,\ + raw_read_packet,\ + raw_read_close,\ + extensions: ext,\ + value: codec,\ +};\ +\ +AVOutputFormat pcm_ ## name ## _oformat = {\ + #name,\ + long_name,\ + NULL,\ + ext,\ + 0,\ + codec,\ + 0,\ + raw_write_header,\ + raw_write_packet,\ + raw_write_trailer,\ }; -AVFormat pcm_u16be_format = { - "u16be", - "pcm unsigned 16 bit big endian format", - NULL, #ifdef WORDS_BIGENDIAN - "uw", +#define BE_DEF(s) s +#define LE_DEF(s) NULL #else - "", +#define BE_DEF(s) NULL +#define LE_DEF(s) s #endif - CODEC_ID_PCM_U16BE, - 0, - raw_write_header, - raw_write_packet, - raw_write_trailer, - raw_read_header, - raw_read_packet, - raw_read_close, -}; -AVFormat pcm_s8_format = { - "s8", - "pcm signed 8 bit format", - NULL, - "sb", - CODEC_ID_PCM_S8, - 0, - raw_write_header, - raw_write_packet, - raw_write_trailer, +PCMDEF(s16le, "pcm signed 16 bit little endian format", + LE_DEF("sw"), CODEC_ID_PCM_S16LE) - raw_read_header, - raw_read_packet, - raw_read_close, -}; +PCMDEF(s16be, "pcm signed 16 bit big endian format", + BE_DEF("sw"), CODEC_ID_PCM_S16BE) -AVFormat pcm_u8_format = { - "u8", - "pcm unsigned 8 bit format", - NULL, - "ub", - CODEC_ID_PCM_U8, - 0, - raw_write_header, - raw_write_packet, - raw_write_trailer, +PCMDEF(u16le, "pcm unsigned 16 bit little endian format", + LE_DEF("uw"), CODEC_ID_PCM_U16LE) - raw_read_header, - raw_read_packet, - raw_read_close, -}; +PCMDEF(u16be, "pcm unsigned 16 bit big endian format", + BE_DEF("uw"), CODEC_ID_PCM_U16BE) -AVFormat pcm_mulaw_format = { - "mulaw", - "pcm mu law format", - NULL, - "ul", - CODEC_ID_PCM_MULAW, - 0, - raw_write_header, - raw_write_packet, - raw_write_trailer, +PCMDEF(s8, "pcm signed 8 bit format", + "sb", CODEC_ID_PCM_S8) - raw_read_header, - raw_read_packet, - raw_read_close, -}; +PCMDEF(u8, "pcm unsigned 8 bit format", + "ub", CODEC_ID_PCM_U8) -AVFormat pcm_alaw_format = { - "alaw", - "pcm A law format", - NULL, - "al", - CODEC_ID_PCM_ALAW, - 0, - raw_write_header, - raw_write_packet, - raw_write_trailer, +PCMDEF(mulaw, "pcm mu law format", + "ul", CODEC_ID_PCM_MULAW) - raw_read_header, - raw_read_packet, - raw_read_close, -}; +PCMDEF(alaw, "pcm A law format", + "al", CODEC_ID_PCM_ALAW) int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt) @@ -416,18 +382,65 @@ int rawvideo_read_packet(AVFormatContext *s, } } -AVFormat rawvideo_format = { +AVInputFormat rawvideo_iformat = { + "rawvideo", + "raw video format", + 0, + NULL, + raw_read_header, + rawvideo_read_packet, + raw_read_close, + extensions: "yuv", + value: CODEC_ID_RAWVIDEO, +}; + +AVOutputFormat rawvideo_oformat = { "rawvideo", "raw video format", NULL, "yuv", + 0, CODEC_ID_NONE, CODEC_ID_RAWVIDEO, raw_write_header, raw_write_packet, raw_write_trailer, - - raw_read_header, - rawvideo_read_packet, - raw_read_close, }; + +int raw_init(void) +{ + av_register_input_format(&mp3_iformat); + av_register_output_format(&mp2_oformat); + + av_register_input_format(&ac3_iformat); + av_register_output_format(&ac3_oformat); + + av_register_output_format(&h263_oformat); + + av_register_input_format(&mpegvideo_iformat); + av_register_output_format(&mpeg1video_oformat); + + av_register_input_format(&mjpeg_iformat); + av_register_output_format(&mjpeg_oformat); + + av_register_input_format(&pcm_s16le_iformat); + av_register_output_format(&pcm_s16le_oformat); + av_register_input_format(&pcm_s16be_iformat); + av_register_output_format(&pcm_s16be_oformat); + av_register_input_format(&pcm_u16le_iformat); + av_register_output_format(&pcm_u16le_oformat); + av_register_input_format(&pcm_u16be_iformat); + av_register_output_format(&pcm_u16be_oformat); + av_register_input_format(&pcm_s8_iformat); + av_register_output_format(&pcm_s8_oformat); + av_register_input_format(&pcm_u8_iformat); + av_register_output_format(&pcm_u8_oformat); + av_register_input_format(&pcm_mulaw_iformat); + av_register_output_format(&pcm_mulaw_oformat); + av_register_input_format(&pcm_alaw_iformat); + av_register_output_format(&pcm_alaw_oformat); + + av_register_input_format(&rawvideo_iformat); + av_register_output_format(&rawvideo_oformat); + return 0; +} diff --git a/libav/rm.c b/libav/rm.c index 5608499979..477ef2acf8 100644 --- a/libav/rm.c +++ b/libav/rm.c @@ -281,17 +281,11 @@ static void write_packet_header(AVFormatContext *ctx, StreamInfo *stream, static int rm_write_header(AVFormatContext *s) { + RMContext *rm = s->priv_data; StreamInfo *stream; - RMContext *rm; int n; AVCodecContext *codec; - rm = av_malloc(sizeof(RMContext)); - if (!rm) - return -1; - memset(rm, 0, sizeof(RMContext)); - s->priv_data = rm; - for(n=0;nnb_streams;n++) { s->streams[n]->id = n; codec = &s->streams[n]->codec; @@ -438,8 +432,6 @@ static int rm_write_trailer(AVFormatContext *s) put_be32(pb, 0); } put_flush_packet(pb); - - av_free(rm); return 0; } @@ -475,7 +467,7 @@ static void get_str8(ByteIOContext *pb, char *buf, int buf_size) static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap) { - RMContext *rm; + RMContext *rm = s->priv_data; AVStream *st; ByteIOContext *pb = &s->pb; unsigned int tag, v; @@ -487,10 +479,6 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap) if (get_le32(pb) != MKTAG('.', 'R', 'M', 'F')) return -EIO; - rm = av_mallocz(sizeof(RMContext)); - if (!rm) - return -ENOMEM; - s->priv_data = rm; get_be32(pb); /* header size */ get_be16(pb); @@ -579,7 +567,7 @@ static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap) st->codec.codec_id = CODEC_ID_AC3; } else { st->codec.codec_id = CODEC_ID_NONE; - nstrcpy(st->codec.codec_name, sizeof(st->codec.codec_name), + pstrcpy(st->codec.codec_name, sizeof(st->codec.codec_name), buf); } } else { @@ -706,23 +694,48 @@ static int rm_read_packet(AVFormatContext *s, AVPacket *pkt) static int rm_read_close(AVFormatContext *s) { - RMContext *rm = s->priv_data; - av_free(rm); return 0; } -AVFormat rm_format = { +static int rm_probe(AVProbeData *p) +{ + /* check file header */ + if (p->buf_size <= 32) + return 0; + if (p->buf[0] == '.' && p->buf[1] == 'R' && + p->buf[2] == 'M' && p->buf[3] == 'F' && + p->buf[4] == 0 && p->buf[5] == 0) + return AVPROBE_SCORE_MAX; + else + return 0; +} + +AVInputFormat rm_iformat = { + "rm", + "rm format", + sizeof(RMContext), + rm_probe, + rm_read_header, + rm_read_packet, + rm_read_close, +}; + +AVOutputFormat rm_oformat = { "rm", "rm format", "audio/x-pn-realaudio", "rm,ra", + sizeof(RMContext), CODEC_ID_AC3, CODEC_ID_RV10, rm_write_header, rm_write_packet, rm_write_trailer, - - rm_read_header, - rm_read_packet, - rm_read_close, }; + +int rm_init(void) +{ + av_register_input_format(&rm_iformat); + av_register_output_format(&rm_oformat); + return 0; +} diff --git a/libav/swf.c b/libav/swf.c index 092f1d72c6..79ef4bba51 100644 --- a/libav/swf.c +++ b/libav/swf.c @@ -438,6 +438,19 @@ static int get_swf_tag(ByteIOContext *pb, int *len_ptr) return tag; } + +static int swf_probe(AVProbeData *p) +{ + /* check file header */ + if (p->buf_size <= 16) + return 0; + if (p->buf[0] == 'F' && p->buf[1] == 'W' && + p->buf[2] == 'S' && p->buf[3] == '\0') + return AVPROBE_SCORE_MAX; + else + return 0; +} + static int swf_read_header(AVFormatContext *s, AVFormatParameters *ap) { ByteIOContext *pb = &s->pb; @@ -528,18 +541,32 @@ static int swf_read_close(AVFormatContext *s) return 0; } -AVFormat swf_format = { +static AVInputFormat swf_iformat = { + "swf", + "Flash format", + 0, + swf_probe, + swf_read_header, + swf_read_packet, + swf_read_close, +}; + +static AVOutputFormat swf_oformat = { "swf", "Flash format", "application/x-shockwave-flash", "swf", + sizeof(SWFContext), CODEC_ID_MP2, CODEC_ID_MJPEG, swf_write_header, swf_write_packet, swf_write_trailer, - - swf_read_header, - swf_read_packet, - swf_read_close, }; + +int swf_init(void) +{ + av_register_input_format(&swf_iformat); + av_register_output_format(&swf_oformat); + return 0; +} diff --git a/libav/wav.c b/libav/wav.c index a50d6f86f3..b634b977ce 100644 --- a/libav/wav.c +++ b/libav/wav.c @@ -110,16 +110,10 @@ typedef struct { static int wav_write_header(AVFormatContext *s) { - WAVContext *wav; + WAVContext *wav = s->priv_data; ByteIOContext *pb = &s->pb; offset_t fmt; - wav = av_malloc(sizeof(WAVContext)); - if (!wav) - return -1; - memset(wav, 0, sizeof(WAVContext)); - s->priv_data = wav; - put_tag(pb, "RIFF"); put_le32(pb, 0); /* file length */ put_tag(pb, "WAVE"); @@ -165,8 +159,6 @@ static int wav_write_trailer(AVFormatContext *s) put_flush_packet(pb); } - - av_free(wav); return 0; } @@ -191,6 +183,20 @@ static int find_tag(ByteIOContext *pb, UINT32 tag1) return size; } +static int wav_probe(AVProbeData *p) +{ + /* check file header */ + if (p->buf_size <= 32) + return 0; + if (p->buf[0] == 'R' && p->buf[1] == 'I' && + p->buf[2] == 'F' && p->buf[3] == 'F' && + p->buf[8] == 'W' && p->buf[9] == 'A' && + p->buf[10] == 'V' && p->buf[11] == 'E') + return AVPROBE_SCORE_MAX; + else + return 0; +} + /* wav input */ static int wav_read_header(AVFormatContext *s, AVFormatParameters *ap) @@ -233,14 +239,10 @@ static int wav_read_header(AVFormatContext *s, return -1; /* now we are ready: build format streams */ - st = av_malloc(sizeof(AVStream)); + st = av_new_stream(s, 0); if (!st) - return -1; - s->nb_streams = 1; - s->streams[0] = st; + return AVERROR_NOMEM; - st->id = 0; - st->codec.codec_type = CODEC_TYPE_AUDIO; st->codec.codec_tag = id; st->codec.codec_id = wav_codec_get_id(id, bps); @@ -280,18 +282,32 @@ static int wav_read_close(AVFormatContext *s) return 0; } -AVFormat wav_format = { +static AVInputFormat wav_iformat = { + "wav", + "wav format", + 0, + wav_probe, + wav_read_header, + wav_read_packet, + wav_read_close, +}; + +static AVOutputFormat wav_oformat = { "wav", "wav format", "audio/x-wav", "wav", + sizeof(WAVContext), CODEC_ID_PCM_S16LE, CODEC_ID_NONE, wav_write_header, wav_write_packet, wav_write_trailer, - - wav_read_header, - wav_read_packet, - wav_read_close, }; + +int wav_init(void) +{ + av_register_input_format(&wav_iformat); + av_register_output_format(&wav_oformat); + return 0; +}