@@ -386,102 +386,6 @@ static void do_audio_out(AVFormatContext *s,

     }

 }

-/* write a picture to a raw mux */

-static void write_picture(AVFormatContext *s, int index, AVPicture *picture, 

-                          int pix_fmt, int w, int h)

-{

-    uint8_t *buf, *src, *dest;

-    int size, j, i;

-

-    /* XXX: not efficient, should add test if we can take

-       directly the AVPicture */

-    switch(pix_fmt) {

-    case PIX_FMT_YUV420P:

-        size = avpicture_get_size(pix_fmt, w, h);

-        buf = av_malloc(size);

-        if (!buf)

-            return;

-        dest = buf;

-        for(i=0;i<3;i++) {

-            if (i == 1) {

-                w >>= 1;

-                h >>= 1;

-            }

-            src = picture->data[i];

-            for(j=0;j<h;j++) {

-                memcpy(dest, src, w);

-                dest += w;

-                src += picture->linesize[i];

-            }

-        }

-        break;

-    case PIX_FMT_YUV422P:

-        size = (w * h) * 2; 

-        buf = av_malloc(size);

-        if (!buf)

-            return;

-        dest = buf;

-        for(i=0;i<3;i++) {

-            if (i == 1) {

-                w >>= 1;

-            }

-            src = picture->data[i];

-            for(j=0;j<h;j++) {

-                memcpy(dest, src, w);

-                dest += w;

-                src += picture->linesize[i];

-            }

-        }

-        break;

-    case PIX_FMT_YUV444P:

-        size = (w * h) * 3; 

-        buf = av_malloc(size);

-        if (!buf)

-            return;

-        dest = buf;

-        for(i=0;i<3;i++) {

-            src = picture->data[i];

-            for(j=0;j<h;j++) {

-                memcpy(dest, src, w);

-                dest += w;

-                src += picture->linesize[i];

-            }

-        }

-        break;

-    case PIX_FMT_YUV422:

-        size = (w * h) * 2; 

-        buf = av_malloc(size);

-        if (!buf)

-            return;

-        dest = buf;

-        src = picture->data[0];

-        for(j=0;j<h;j++) {

-            memcpy(dest, src, w * 2);

-            dest += w * 2;

-            src += picture->linesize[0];

-        }

-        break;

-    case PIX_FMT_RGB24:

-    case PIX_FMT_BGR24:

-        size = (w * h) * 3; 

-        buf = av_malloc(size);

-        if (!buf)

-            return;

-        dest = buf;

-        src = picture->data[0];

-        for(j=0;j<h;j++) {

-            memcpy(dest, src, w * 3);

-            dest += w * 3;

-            src += picture->linesize[0];

-        }

-        break;

-    default:

-        return;

-    }

-    av_write_frame(s, index, buf, size);

-    av_free(buf);

-}

-

 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)

 {

     AVCodecContext *dec;

@@ -657,7 +561,13 @@ static void do_video_out(AVFormatContext *s,

     /* duplicates frame if needed */

     /* XXX: pb because no interleaving */

     for(i=0;i<nb_frames;i++) {

-        if (enc->codec_id != CODEC_ID_RAWVIDEO) {

+        if (s->oformat->flags & AVFMT_RAWPICTURE) {

+            /* raw pictures are written as AVPicture structure to

+               avoid any copies. We support temorarily the older

+               method. */

+            av_write_frame(s, ost->index, 

+                           (uint8_t *)final_picture, sizeof(AVPicture));

+        } else {

             AVFrame big_picture;

             memset(&big_picture, 0, sizeof(AVFrame));

@@ -683,17 +593,6 @@ static void do_video_out(AVFormatContext *s,

             if (ost->logfile && enc->stats_out) {

                 fprintf(ost->logfile, "%s", enc->stats_out);

             }

-        } else {

-            if (s->oformat->flags & AVFMT_RAWPICTURE) {

-                /* raw pictures are written as AVPicture structure to

-                   avoid any copies. We support temorarily the older

-                   method. */

-                av_write_frame(s, ost->index, 

-                               (uint8_t *)final_picture, sizeof(AVPicture));

-            } else {

-                write_picture(s, ost->index, final_picture, enc->pix_fmt, 

-                              enc->width, enc->height);

-            }

         }

         ost->frame_number++;

     }

@@ -1311,16 +1210,7 @@ static int av_encode(AVFormatContext **output_files,

                     data_buf = (uint8_t *)samples;

                     break;

                 case CODEC_TYPE_VIDEO:

-                    if (ist->st->codec.codec_id == CODEC_ID_RAWVIDEO) {

-                        int size;

-

-                        size = (ist->st->codec.width * ist->st->codec.height);

-                        avpicture_fill(&picture, ptr, 

-                                     ist->st->codec.pix_fmt,

-                                     ist->st->codec.width,

-                                     ist->st->codec.height);

-                        ret = len;

-                    } else {

+                    {

                         AVFrame big_picture;

                         data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;

@@ -16,7 +16,7 @@ OBJS= common.o utils.o mem.o allcodecs.o \

       motion_est.o imgconvert.o imgresample.o \

       mpeg12.o mpegaudiodec.o pcm.o simple_idct.o \

       ratecontrol.o adpcm.o eval.o dv.o error_resilience.o \

-      fft.o mdct.o mace.o huffyuv.o cyuv.o opts.o

+      fft.o mdct.o mace.o huffyuv.o cyuv.o opts.o raw.o

 ASM_OBJS=

 # codecs which are patented in some non free countries like the us

@@ -907,6 +907,10 @@ static inline int ff_get_fourcc(const char *s){

     return (s[0]) + (s[1]<<8) + (s[2]<<16) + (s[3]<<24);

 }

+#define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24))

+#define MKBETAG(a,b,c,d) (d | (c << 8) | (b << 16) | (a << 24))

+

+

 void ff_float2fraction(int *nom_arg, int *denom_arg, double f, int max);

new file mode 100644

@@ -0,0 +1,204 @@

+/*

+ * Raw Video Codec

+ * Copyright (c) 2001 Fabrice Bellard.

+ *

+ * This library is free software; you can redistribute it and/or

+ * modify it under the terms of the GNU Lesser General Public

+ * License as published by the Free Software Foundation; either

+ * version 2 of the License, or (at your option) any later version.

+ *

+ * This library is distributed in the hope that it will be useful,

+ * but WITHOUT ANY WARRANTY; without even the implied warranty of

+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

+ * Lesser General Public License for more details.

+ *

+ * You should have received a copy of the GNU Lesser General Public

+ * License along with this library; if not, write to the Free Software

+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

+ */

+ 

+/**

+ * @file raw.c

+ * Raw Video Codec

+ */

+ 

+#include "avcodec.h"

+

+

+typedef struct PixleFormatTag {

+    int pix_fmt;

+    unsigned int fourcc;

+} PixelFormatTag;

+

+const PixelFormatTag pixelFormatTags[] = {

+    { PIX_FMT_YUV422, MKTAG('Y', '4', '2', '2') },

+    { -1, 0 },

+};

+

+static int findPixelFormat(unsigned int fourcc)

+{

+    const PixelFormatTag * tags = pixelFormatTags;

+    while (tags->pix_fmt >= 0) {

+        if (tags->fourcc == fourcc)

+            return tags->pix_fmt;

+        tags++;

+    }

+    return PIX_FMT_YUV420P;

+}

+

+

+typedef struct RawVideoContext {

+    unsigned char * buffer;  /* block of memory for holding one frame */

+    unsigned char * p;       /* current position in buffer */

+    int             length;  /* number of bytes in buffer */

+} RawVideoContext;

+

+

+static int raw_init(AVCodecContext *avctx)

+{

+    RawVideoContext *context = avctx->priv_data;

+

+    if (avctx->codec_tag) {

+	    avctx->pix_fmt = findPixelFormat(avctx->codec_tag);

+    }

+

+	context->length = avpicture_get_size(avctx->pix_fmt, avctx->width, avctx->height);

+	context->buffer = av_malloc(context->length);

+	context->p      = context->buffer;

+

+    if (! context->buffer) {

+        return -1;

+    }

+

+    return 0;

+}

+

+static int raw_decode(AVCodecContext *avctx,

+			    void *data, int *data_size,

+			    uint8_t *buf, int buf_size)

+{

+    RawVideoContext *context = avctx->priv_data;

+

+    AVPicture * picture = (AVPicture *) data;

+

+    /* Early out without copy if packet size == frame size */

+    if (buf_size == context->length  &&  context->p == context->buffer) {

+        avpicture_fill(picture, buf, avctx->pix_fmt, avctx->width, avctx->height);

+        *data_size = sizeof(AVPicture);

+        return buf_size;

+    }

+

+    int bytesNeeded = context->length - (context->p - context->buffer);

+    if (buf_size < bytesNeeded) {

+        memcpy(context->p, buf, buf_size);

+        context->p += buf_size;

+        *data_size = 0;

+        return buf_size;

+    }

+

+    memcpy(context->p, buf, bytesNeeded);

+    context->p = context->buffer;

+    avpicture_fill(picture, context->buffer, avctx->pix_fmt, avctx->width, avctx->height);

+    *data_size = sizeof(AVPicture);

+    return bytesNeeded;

+}

+

+static int raw_close(AVCodecContext *avctx)

+{

+    RawVideoContext *context = avctx->priv_data;

+

+    av_freep(& context->buffer);

+

+    return 0;

+}

+

+static int raw_encode(AVCodecContext *avctx,

+			    unsigned char *frame, int buf_size, void *data)

+{

+	AVPicture * picture = data;

+

+    unsigned char *src;

+	unsigned char *dest = frame;

+    int i, j;

+

+	int w = avctx->width;

+	int h = avctx->height;

+	int size = avpicture_get_size(avctx->pix_fmt, w, h);

+

+    if (size > buf_size) {

+        return -1;

+    }

+

+    switch(avctx->pix_fmt) {

+    case PIX_FMT_YUV420P:

+        for(i=0;i<3;i++) {

+            if (i == 1) {

+                w >>= 1;

+                h >>= 1;

+            }

+            src = picture->data[i];

+            for(j=0;j<h;j++) {

+                memcpy(dest, src, w);

+                dest += w;

+                src += picture->linesize[i];

+            }

+        }

+        break;

+    case PIX_FMT_YUV422P:

+        for(i=0;i<3;i++) {

+            if (i == 1) {

+                w >>= 1;

+            }

+            src = picture->data[i];

+            for(j=0;j<h;j++) {

+                memcpy(dest, src, w);

+                dest += w;

+                src += picture->linesize[i];

+            }

+        }

+        break;

+    case PIX_FMT_YUV444P:

+        for(i=0;i<3;i++) {

+            src = picture->data[i];

+            for(j=0;j<h;j++) {

+                memcpy(dest, src, w);

+                dest += w;

+                src += picture->linesize[i];

+            }

+        }

+        break;

+    case PIX_FMT_YUV422:

+        src = picture->data[0];

+        for(j=0;j<h;j++) {

+            memcpy(dest, src, w * 2);

+            dest += w * 2;

+            src += picture->linesize[0];

+        }

+        break;

+    case PIX_FMT_RGB24:

+    case PIX_FMT_BGR24:

+        src = picture->data[0];

+        for(j=0;j<h;j++) {

+            memcpy(dest, src, w * 3);

+            dest += w * 3;

+            src += picture->linesize[0];

+        }

+        break;

+    default:

+        return -1;

+    }

+

+    return size;

+}

+

+

+AVCodec rawvideo_codec = {

+    "rawvideo",

+    CODEC_TYPE_VIDEO,

+    CODEC_ID_RAWVIDEO,

+    sizeof(RawVideoContext),

+    raw_init,

+    raw_encode,

+    raw_close,

+    raw_decode,

+};

@@ -647,32 +647,3 @@ int64_t av_rescale(int64_t a, int b, int c){

     return ((h/c)<<32) + l/c;

 }

-

-static int raw_encode_init(AVCodecContext *s)

-{

-    return 0;

-}

-

-static int raw_decode_frame(AVCodecContext *avctx,

-			    void *data, int *data_size,

-			    uint8_t *buf, int buf_size)

-{

-    return -1;

-}

-

-static int raw_encode_frame(AVCodecContext *avctx,

-			    unsigned char *frame, int buf_size, void *data)

-{

-    return -1;

-}

-

-AVCodec rawvideo_codec = {

-    "rawvideo",

-    CODEC_TYPE_VIDEO,

-    CODEC_ID_RAWVIDEO,

-    0,

-    raw_encode_init,

-    raw_encode_frame,

-    NULL,

-    raw_decode_frame,

-};

@@ -331,9 +331,6 @@ int redir_open(AVFormatContext **ic_ptr, ByteIOContext *f);

 extern AVOutputFormat yuv4mpegpipe_oformat;

 /* utils.c */

-#define MKTAG(a,b,c,d) (a | (b << 8) | (c << 16) | (d << 24))

-#define MKBETAG(a,b,c,d) (d | (c << 8) | (b << 16) | (a << 24))

-

 void av_register_input_format(AVInputFormat *format);

 void av_register_output_format(AVOutputFormat *format);

 AVOutputFormat *guess_stream_format(const char *short_name, 

@@ -89,6 +89,7 @@ const CodecTag codec_bmp_tags[] = {

     { CODEC_ID_HUFFYUV, MKTAG('h', 'f', 'y', 'u') },

     { CODEC_ID_CYUV, MKTAG('C', 'Y', 'U', 'V') },

     { CODEC_ID_CYUV, MKTAG('c', 'y', 'u', 'v') },

+    { CODEC_ID_RAWVIDEO, MKTAG('Y', '4', '2', '2') },

     { 0, 0 },

 };

@@ -249,12 +250,17 @@ static int avi_write_header(AVFormatContext *s)

         stream = &s->streams[i]->codec;

+        /* FourCC should really be set by the codec itself */

+        if (! stream->codec_tag) {

+            stream->codec_tag = codec_get_bmp_tag(stream->codec_id);

+        }

+

         /* stream generic header */

         strh = start_tag(pb, "strh");

         switch(stream->codec_type) {

         case CODEC_TYPE_VIDEO:

             put_tag(pb, "vids");

-            put_le32(pb, codec_get_bmp_tag(stream->codec_id));

+            put_le32(pb, stream->codec_tag);

             put_le32(pb, 0); /* flags */

             put_le16(pb, 0); /* priority */

             put_le16(pb, 0); /* language */