rawvideo patch by (Fred Rothganger <rothgang at uiuc dot edu>)

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

ffmpeg.c

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

libavcodec/Makefile

@@ -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

libavcodec/common.h

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

libavcodec/raw.c

+/*
+ * 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,
+};

libavcodec/utils.c

@@ -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,
-};

libavformat/avformat.h

@@ -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, 

libavformat/avienc.c

@@ -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 */