* introducing new public interface in imgconvert.c

       + avcodec_get_pix_fmt
         converts textual representation of pixel format into
	 the actual id. Complements avcodec_get_pix_fmt_name.
       + avpicture_layout
         serializes given picture into a flat array.
	 Complements avpicture_fill.

   * adding a new option -pix_fmt to the ffmpeg, in order to control
     pixel format for the codecs that do support it, like rawvideo,
     for example.

   * reducing complexity of the rawvideo codec by splitting it in two
     and making it more reliable via hooking up to the avpicture_layout.
     Plus adding new FourCC as described here: http://www.fourcc.org

   * A tiny fix for avienc.c that makes avih and video strf consistent
     regarding codec FourCC.

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

ffmpeg.c

@@ -89,6 +89,7 @@ static AVImageFormat *image_format;
 static int frame_width  = 160;
 static int frame_height = 128;
 static float frame_aspect_ratio = 0;
+static enum PixelFormat frame_pix_fmt = PIX_FMT_YUV420P;
 static int frame_topBand  = 0;
 static int frame_bottomBand = 0;
 static int frame_leftBand  = 0;
@@ -1706,6 +1707,11 @@ static void opt_frame_size(const char *arg)
     }
 }
 
+static void opt_frame_pix_fmt(const char *arg)
+{
+    frame_pix_fmt = avcodec_get_pix_fmt(arg);
+}
+
 static void opt_frame_aspect_ratio(const char *arg)
 {
     int x = 0, y = 0;
@@ -2032,6 +2038,7 @@ static void opt_input_file(const char *filename)
     ap->width = frame_width;
     ap->height = frame_height;
     ap->image_format = image_format;
+    ap->pix_fmt = frame_pix_fmt;
 
     /* open the input file with generic libav function */
     err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
@@ -2061,6 +2068,7 @@ static void opt_input_file(const char *filename)
             frame_height = enc->height;
             frame_width = enc->width;
 	    frame_aspect_ratio = enc->aspect_ratio;
+	    frame_pix_fmt = enc->pix_fmt;
             rfps      = ic->streams[i]->r_frame_rate;
             rfps_base = ic->streams[i]->r_frame_rate_base;
             enc->workaround_bugs = workaround_bugs;
@@ -2218,6 +2226,7 @@ static void opt_output_file(const char *filename)
                 video_enc->width = frame_width;
                 video_enc->height = frame_height;
 		video_enc->aspect_ratio = frame_aspect_ratio;
+		video_enc->pix_fmt = frame_pix_fmt;
 
                 if (!intra_only)
                     video_enc->gop_size = gop_size;
@@ -2722,6 +2731,7 @@ const OptionDef options[] = {
     { "re", OPT_BOOL|OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate" },
     { "s", HAS_ARG, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
     { "aspect", HAS_ARG, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
+    { "pix_fmt", HAS_ARG | OPT_EXPERT, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
     { "croptop", HAS_ARG, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
     { "cropbottom", HAS_ARG, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
     { "cropleft", HAS_ARG, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },

libavcodec/allcodecs.c

@@ -65,7 +65,8 @@ void avcodec_register_all(void)
     register_avcodec(&mjpeg_encoder);
     register_avcodec(&huffyuv_encoder);
 #endif /* CONFIG_ENCODERS */
-    register_avcodec(&rawvideo_codec);
+    register_avcodec(&rawvideo_encoder);
+    register_avcodec(&rawvideo_decoder);
 
     /* decoders */
 #ifdef CONFIG_DECODERS

libavcodec/avcodec.h

@@ -1244,7 +1244,8 @@ PCM_CODEC(CODEC_ID_ADPCM_MS, adpcm_ms);
 #undef PCM_CODEC
 
 /* dummy raw video codec */
-extern AVCodec rawvideo_codec;
+extern AVCodec rawvideo_encoder;
+extern AVCodec rawvideo_decoder;
 
 /* the following codecs use external GPL libs */
 extern AVCodec ac3_decoder;
@@ -1281,9 +1282,12 @@ void img_resample_close(ImgReSampleContext *s);
 
 int avpicture_fill(AVPicture *picture, uint8_t *ptr,
                    int pix_fmt, int width, int height);
+int avpicture_layout(AVPicture* src, int pix_fmt, int width, int height,
+                     unsigned char *dest, int dest_size);
 int avpicture_get_size(int pix_fmt, int width, int height);
 void avcodec_get_chroma_sub_sample(int pix_fmt, int *h_shift, int *v_shift);
 const char *avcodec_get_pix_fmt_name(int pix_fmt);
+enum PixelFormat avcodec_get_pix_fmt(const char* name);
 
 #define FF_LOSS_RESOLUTION  0x0001 /* loss due to resolution change */
 #define FF_LOSS_DEPTH       0x0002 /* loss due to color depth change */

libavcodec/imgconvert.c

@@ -224,6 +224,16 @@ const char *avcodec_get_pix_fmt_name(int pix_fmt)
         return pix_fmt_info[pix_fmt].name;
 }
 
+enum PixelFormat avcodec_get_pix_fmt(const char* name)
+{
+    int i; 
+    
+    for (i=0; i < PIX_FMT_NB; i++)
+         if (!strcmp(pix_fmt_info[i].name, name))
+	     break;
+    return i;
+}
+
 /* Picture field are filled with 'ptr' addresses. Also return size */
 int avpicture_fill(AVPicture *picture, uint8_t *ptr,
                    int pix_fmt, int width, int height)
@@ -303,6 +313,47 @@ int avpicture_fill(AVPicture *picture, uint8_t *ptr,
     }
 }
 
+int avpicture_layout(AVPicture* src, int pix_fmt, int width, int height,
+                     unsigned char *dest, int dest_size)
+{
+    PixFmtInfo* pf = &pix_fmt_info[pix_fmt];
+    int i, j, w, h, data_planes;
+    unsigned char* s; 
+    int size = avpicture_get_size(pix_fmt, width, height);
+
+    if (size > dest_size)
+        return -1;
+
+    if (pf->pixel_type == FF_PIXEL_PACKED) {
+        if (pix_fmt == PIX_FMT_YUV422 || pix_fmt == PIX_FMT_RGB565 ||
+	    pix_fmt == PIX_FMT_RGB555)
+	  w = width * 2;
+	else
+	  w = width * (pf->depth * pf->nb_channels / 8);
+	data_planes = 1;
+	h = height;
+    } else {
+        data_planes = pf->nb_channels;
+	w = width;
+	h = height;
+    }
+    
+    for (i=0; i<data_planes; i++) {
+         if (i == 1) {
+	     w = width >> pf->x_chroma_shift;
+	     h = height >> pf->y_chroma_shift;
+	 }
+         s = src->data[i];
+	 for(j=0; j<h; j++) {
+	     memcpy(dest, s, w);
+	     dest += w;
+	     s += src->linesize[i];
+	 }
+    }
+
+    return size;
+}
+
 int avpicture_get_size(int pix_fmt, int width, int height)
 {
     AVPicture dummy_pict;

libavcodec/raw.c

@@ -24,6 +24,12 @@
  
 #include "avcodec.h"
 
+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 */
+    AVFrame pic;             ///< AVCodecContext.coded_frame
+} RawVideoContext;
 
 typedef struct PixleFormatTag {
     int pix_fmt;
@@ -31,8 +37,19 @@ typedef struct PixleFormatTag {
 } PixelFormatTag;
 
 const PixelFormatTag pixelFormatTags[] = {
-    { PIX_FMT_YUV422, MKTAG('Y', '4', '2', '2') },
-    { PIX_FMT_YUV420P, MKTAG('I', '4', '2', '0') },
+    { PIX_FMT_YUV420P, MKTAG('I', '4', '2', '0') }, /* Planar formats */
+    { PIX_FMT_YUV420P, MKTAG('I', 'Y', 'U', 'V') },
+    { PIX_FMT_YUV410P, MKTAG('Y', 'U', 'V', '9') },
+    { PIX_FMT_YUV411P, MKTAG('Y', '4', '1', 'B') },
+    { PIX_FMT_YUV422P, MKTAG('Y', '4', '2', 'B') },
+    { PIX_FMT_GRAY8,   MKTAG('Y', '8', '0', '0') },
+    { PIX_FMT_GRAY8,   MKTAG(' ', ' ', 'Y', '8') },
+
+
+    { PIX_FMT_YUV422,  MKTAG('Y', '4', '2', '2') }, /* Packed formats */
+    { PIX_FMT_YUV422,  MKTAG('U', 'Y', 'V', 'Y') },
+    { PIX_FMT_GRAY8,   MKTAG('G', 'R', 'E', 'Y') },
+
     { -1, 0 },
 };
 
@@ -47,34 +64,36 @@ static int findPixelFormat(unsigned int fourcc)
     return PIX_FMT_YUV420P;
 }
 
+static unsigned int findFourCC(int fmt)
+{
+    const PixelFormatTag * tags = pixelFormatTags;
+    while (tags->pix_fmt >= 0) {
+        if (tags->pix_fmt == fmt)
+	    return tags->fourcc;
+	tags++; 
+    }
+    return 0;
+}
 
-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 */
-    AVFrame pic;             ///< AVCodecContext.coded_frame
-} RawVideoContext;
-
+/* RAW Decoder Implementation */
 
-static int raw_init(AVCodecContext *avctx)
+static int raw_init_decoder(AVCodecContext *avctx)
 {
     RawVideoContext *context = avctx->priv_data;
 
-    if (avctx->codec_tag) {
+    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;
+    context->pic.pict_type = FF_I_TYPE;
+    context->pic.key_frame = 1;
     
-    context->pic.pict_type= FF_I_TYPE;
-    context->pic.key_frame= 1;
     avctx->coded_frame= &context->pic;
     
-    if (! context->buffer) {
+    if (!context->buffer)
         return -1;
-    }
    
     return 0;
 }
@@ -110,102 +129,48 @@ static int raw_decode(AVCodecContext *avctx,
     return bytesNeeded;
 }
 
-static int raw_close(AVCodecContext *avctx)
+static int raw_close_decoder(AVCodecContext *avctx)
 {
     RawVideoContext *context = avctx->priv_data;
     
-    av_freep(& context->buffer);
+    av_freep(&context->buffer);
+    return 0;
+}
+
+/* RAW Encoder Implementation */
 
+static int raw_init_encoder(AVCodecContext *avctx)
+{
+    avctx->coded_frame = (AVPicture*)avctx->priv_data;
+    avctx->coded_frame->pict_type = FF_I_TYPE;
+    avctx->coded_frame->key_frame = 1;
+    avctx->codec_tag = findFourCC(avctx->pix_fmt);
     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;
+    return avpicture_layout((AVPicture *)data, avctx->pix_fmt, avctx->width,
+                                               avctx->height, frame, buf_size);
 }
 
+AVCodec rawvideo_encoder = {
+    "rawvideo",
+    CODEC_TYPE_VIDEO,
+    CODEC_ID_RAWVIDEO,
+    sizeof(AVFrame),
+    raw_init_encoder,
+    raw_encode,
+};
 
-AVCodec rawvideo_codec = {
+AVCodec rawvideo_decoder = {
     "rawvideo",
     CODEC_TYPE_VIDEO,
     CODEC_ID_RAWVIDEO,
     sizeof(RawVideoContext),
-    raw_init,
-    raw_encode,
-    raw_close,
+    raw_init_decoder,
+    NULL,
+    raw_close_decoder,
     raw_decode,
 };

libavformat/avienc.c

@@ -211,7 +211,7 @@ void put_bmp_header(ByteIOContext *pb, AVCodecContext *enc, const CodecTag *tags
     
     put_le16(pb, enc->bits_per_sample ? enc->bits_per_sample : 24); /* depth */
     /* compression type */
-    put_le32(pb, for_asf ? codec_get_asf_tag(tags, enc->codec_id) : codec_get_tag(tags, enc->codec_id));
+    put_le32(pb, for_asf ? codec_get_asf_tag(tags, enc->codec_id) : enc->codec_tag);
     put_le32(pb, enc->width * enc->height * 3);
     put_le32(pb, 0);
     put_le32(pb, 0);

libavformat/raw.c

@@ -65,6 +65,7 @@ static int raw_read_header(AVFormatContext *s, AVFormatParameters *ap)
             st->codec.frame_rate_base = ap->frame_rate_base;
             st->codec.width = ap->width;
             st->codec.height = ap->height;
+	    st->codec.pix_fmt = ap->pix_fmt;
             break;
         default:
             return -1;
@@ -455,21 +456,9 @@ static int rawvideo_read_packet(AVFormatContext *s, AVPacket *pkt)
     width = st->codec.width;
     height = st->codec.height;
 
-    switch(st->codec.pix_fmt) {
-    case PIX_FMT_YUV420P:
-        packet_size = (width * height * 3) / 2;
-        break;
-    case PIX_FMT_YUV422:
-        packet_size = (width * height * 2);
-        break;
-    case PIX_FMT_BGR24:
-    case PIX_FMT_RGB24:
-        packet_size = (width * height * 3);
-        break;
-    default:
+    packet_size = avpicture_get_size(st->codec.pix_fmt, width, height);
+    if (packet_size < 0)
         av_abort();
-        break;
-    }
 
     if (av_new_packet(pkt, packet_size) < 0)
         return -EIO;