converted to new API

Originally committed as revision 547 to svn://svn.ffmpeg.org/ffmpeg/trunk

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 \
+OBJS= utils.o 
-	 avidec.o ffm.o \
+
-	 avio.o aviobuf.o utils.o \
+# mux and demuxes
-	 file.o img.o au.o gif.o mov.o crc.o
+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 

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;
+    ASFContext *asf = s->priv_data;
-
-    asf = av_mallocz(sizeof(ASFContext));
-    if (!asf)
-        return -1;
-    s->priv_data = asf;
 
     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;
+}

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;
+}

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));
+    st = av_new_stream(s1, 0);
-    if (!s)
-        return -ENOMEM;
-    st = av_mallocz(sizeof(AVStream));
     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,
-
+    flags: AVFMT_NOFILE,
-    audio_read_header,
-    audio_read_packet,
-    audio_read_close,
-    NULL,
-    AVFMT_NOFILE,
 };
+
+int audio_init(void)
+{
+    av_register_input_format(&audio_in_format);
+    av_register_output_format(&audio_out_format);
+    return 0;
+}

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);

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;
+    return 0;
-    av_free(avi);
+}
+
+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;
 }

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;
+}

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;

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;
 

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;
+    CRCState *crc = s->priv_data;
-    crc = av_malloc(sizeof(CRCState));
+
-    if (!crc)
-        return -1;
-    s->priv_data = crc;
-    
     /* 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;
+}

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;i<s->nb_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;
+}

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;
+}

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));
+    st = av_new_stream(s1, 0);
-    if (!s)
+    if (!st)
         return -ENOMEM;
-    st = av_mallocz(sizeof(AVStream));
-    if (!st) {
-        av_free(s);
-        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",
-    "",
+    sizeof(VideoData),
-    "",
-    CODEC_ID_NONE,
-    CODEC_ID_NONE,
     NULL,
-    NULL,
-    NULL,
-
     grab_read_header,
     grab_read_packet,
     grab_read_close,
-    NULL,
+    flags: AVFMT_NOFILE,
-    AVFMT_NOFILE,
 };
+
+int video_grab_init(void)
+{
+    av_register_input_format(&video_grab_device_format);
+    return 0;
+}

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));
+    st = av_new_stream(s1, 0);
-    if (!s)
-        return -ENOMEM;
-
-    s1->priv_data = s;
-
-    s1->nb_streams = 1;
-    st = av_mallocz(sizeof(AVStream));
     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 ||
+    if (s1->iformat == &pgmyuvpipe_iformat ||
-        s1->format == &pgmyuv_format)
+        s1->iformat == &pgmyuv_iformat)
         s->img_fmt = IMGFMT_PGMYUV;
-    else if (s1->format == &pgmpipe_format ||
+    else if (s1->iformat == &pgmpipe_iformat ||
-             s1->format == &pgm_format)
+             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 ||
+    else if (s1->iformat == &ppmpipe_iformat ||
-             s1->format == &ppm_format)
+             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 ||
+    if (s->oformat == &pgmyuvpipe_oformat ||
-        s->format == &pgmyuv_format) {
+        s->oformat == &pgmyuv_oformat) {
         img->img_fmt = IMGFMT_PGMYUV;
-    } else if (s->format == &pgmpipe_format ||
+    } else if (s->oformat == &pgmpipe_oformat ||
-               s->format == &pgm_format) {
+               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 ||
+    } else if (s->oformat == &ppmpipe_oformat ||
-               s->format == &ppm_format) {
+               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,
-
+    flags: AVFMT_RGB24,
-    img_read_header,
-    img_read_packet,
-    img_read_close,
-    NULL,
 };
+
+
+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;
+}

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,
-
+    flags: AVFMT_NOFILE | AVFMT_NEEDNUMBER,
-    jpeg_read_header,
-    jpeg_read_packet,
-    jpeg_read_close,
-    NULL,
-    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;
+}

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);
+        /* MP4 string */
-        if(len) {
+        for(;;) {
-            buf = av_malloc(len+1);
+            if (len == 0)
-            get_buffer(pb, buf, len);
+                break;
-            buf[len] = '\0';
+            len = get_byte(pb);
-#ifdef DEBUG
-            puts(buf);
-#endif
-            av_free(buf);
         }
     }
     
@@ -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; i<s->nb_streams; i++)
         av_free(s->streams[i]);
-    av_free(mov);
     return 0;
 }
 
-AVFormat mov_format = {
+static AVInputFormat mov_iformat = {
     "mov",
-    "QuickTime format",
+    "QuickTime/MPEG4 format",
-    "video/quicktime",
+    sizeof(MOVContext),
-    "mov",
+    mov_probe,
-    CODEC_ID_MP2,
-    CODEC_ID_MJPEG,
-    NULL,
-    NULL,
-    NULL,
-
     mov_read_header,
     mov_read_packet,
     mov_read_close,
 };
 
-AVFormat mp4_format = {
+int mov_init(void)
-    "mp4",
+{
-    "MPEG4 file format",
+    av_register_input_format(&mov_iformat);
-    "video/mpeg4",
+    return 0;
-    "mp4",
+}
-    CODEC_ID_MP2,
-    CODEC_ID_MJPEG,
-    NULL,
-    NULL,
-    NULL,
-
-    mov_read_header,
-    mov_read_packet,
-    mov_read_close,
-};

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;
+        return AVERROR_NOMEM;
-    s->nb_streams = 1;
-    s->streams[0] = st;
-
-    st->id = 0;
-
     if (ap) {
-        if (s->format->audio_codec != CODEC_ID_NONE) {
+        id = s->iformat->value;
-            st->codec.codec_type = CODEC_TYPE_AUDIO;
+        if (id == CODEC_ID_RAWVIDEO) {
-            st->codec.codec_id = s->format->audio_codec;
-        } else if (s->format->video_codec != CODEC_ID_NONE) {
             st->codec.codec_type = CODEC_TYPE_VIDEO;
-            st->codec.codec_id = s->format->video_codec;
         } else {
-            av_free(st);
+            st->codec.codec_type = CODEC_TYPE_AUDIO;
-            return -1;
         }
-        
+        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;
+        return AVERROR_NOMEM;
-    s->nb_streams = 1;
-    s->streams[0] = st;
-
-    st->id = 0;
 
     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;
+        return AVERROR_NOMEM;
-    s->nb_streams = 1;
-    s->streams[0] = st;
 
     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 = {
+#define SEQ_START_CODE		0x000001b3
-    "mp2",
+#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;i<p->buf_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,
-    raw_read_packet,
-    raw_read_close,
 };
 
-AVFormat ac3_format = {
+
+AVInputFormat ac3_iformat = {
+    "ac3",
+    "raw ac3",
+    0,
+    NULL,
+    raw_read_header,
+    raw_read_packet,
+    raw_read_close,
+    extensions: "ac3",
+    value: CODEC_ID_AC3,
+};
+
+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 = {
+AVOutputFormat mpeg1video_oformat = {
-    "mpegvideo",
+    "mpeg1video",
     "MPEG video",
     "video/x-mpeg",
     "mpg,mpeg",
     0,
+    0,
     CODEC_ID_MPEG1VIDEO,
     raw_write_header,
     raw_write_packet,
     raw_write_trailer,
+};
+
+AVInputFormat mjpeg_iformat = {
+    "mjpeg",
+    "MJPEG video",
+    0,
+    NULL,
     video_read_header,
     raw_read_packet,
     raw_read_close,
+    extensions: "mjpg,mjpeg",
+    value: CODEC_ID_MJPEG,
 };
 
-AVFormat mjpeg_format = {
+AVOutputFormat mjpeg_oformat = {
     "mjpeg",
     "MJPEG video",
     "video/x-mjpeg",
     "mjpg,mjpeg",
     0,
+    0,
     CODEC_ID_MJPEG,
     raw_write_header,
     raw_write_packet,
     raw_write_trailer,
-    video_read_header,
-    raw_read_packet,
-    raw_read_close,
 };
 
 /* pcm formats */
 
-AVFormat pcm_s16le_format = {
+#define PCMDEF(name, long_name, ext, codec) \
-    "s16le",
+AVInputFormat pcm_ ## name ## _iformat = {\
-    "pcm signed 16 bit little endian format",
+    #name,\
-    NULL,
+    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,\
+};
+
 #ifdef WORDS_BIGENDIAN
-    "",
+#define BE_DEF(s) s
+#define LE_DEF(s) NULL
 #else
-    "sw",
+#define BE_DEF(s) NULL
+#define LE_DEF(s) s
 #endif
-    CODEC_ID_PCM_S16LE,
-    0,
-    raw_write_header,
-    raw_write_packet,
-    raw_write_trailer,
 
-    raw_read_header,
-    raw_read_packet,
-    raw_read_close,
-};
 
-AVFormat pcm_s16be_format = {
+PCMDEF(s16le, "pcm signed 16 bit little endian format", 
-    "s16be",
+       LE_DEF("sw"), CODEC_ID_PCM_S16LE)
-    "pcm signed 16 bit big endian format",
-    NULL,
-#ifdef WORDS_BIGENDIAN
-    "sw",
-#else
-    "",
-#endif
-    CODEC_ID_PCM_S16BE,
-    0,
-    raw_write_header,
-    raw_write_packet,
-    raw_write_trailer,
 
-    raw_read_header,
+PCMDEF(s16be, "pcm signed 16 bit big endian format", 
-    raw_read_packet,
+       BE_DEF("sw"), CODEC_ID_PCM_S16BE)
-    raw_read_close,
-};
 
-AVFormat pcm_u16le_format = {
+PCMDEF(u16le, "pcm unsigned 16 bit little endian format", 
-    "u16le",
+       LE_DEF("uw"), CODEC_ID_PCM_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,
 
-    raw_read_header,
+PCMDEF(u16be, "pcm unsigned 16 bit big endian format", 
-    raw_read_packet,
+       BE_DEF("uw"), CODEC_ID_PCM_U16BE)
-    raw_read_close,
-};
 
-AVFormat pcm_u16be_format = {
+PCMDEF(s8, "pcm signed 8 bit format", 
-    "u16be",
+       "sb", CODEC_ID_PCM_S8)
-    "pcm unsigned 16 bit big endian format",
-    NULL,
-#ifdef WORDS_BIGENDIAN
-    "uw",
-#else
-    "",
-#endif
-    CODEC_ID_PCM_U16BE,
-    0,
-    raw_write_header,
-    raw_write_packet,
-    raw_write_trailer,
 
-    raw_read_header,
+PCMDEF(u8, "pcm unsigned 8 bit format", 
-    raw_read_packet,
+       "ub", CODEC_ID_PCM_U8)
-    raw_read_close,
-};
 
-AVFormat pcm_s8_format = {
+PCMDEF(mulaw, "pcm mu law format", 
-    "s8",
+       "ul", CODEC_ID_PCM_MULAW)
-    "pcm signed 8 bit format",
-    NULL,
-    "sb",
-    CODEC_ID_PCM_S8,
-    0,
-    raw_write_header,
-    raw_write_packet,
-    raw_write_trailer,
 
-    raw_read_header,
+PCMDEF(alaw, "pcm A law format", 
-    raw_read_packet,
+       "al", CODEC_ID_PCM_ALAW)
-    raw_read_close,
-};
-
-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,
-
-    raw_read_header,
-    raw_read_packet,
-    raw_read_close,
-};
-
-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,
-
-    raw_read_header,
-    raw_read_packet,
-    raw_read_close,
-};
-
-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,
-
-    raw_read_header,
-    raw_read_packet,
-    raw_read_close,
-};
 
 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;
+}

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;n<s->nb_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;
+}

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;
+}

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;
+        return AVERROR_NOMEM;
-    s->nb_streams = 1;
-    s->streams[0] = st;
 
-    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;
+}