@@ -6,6 +6,7 @@ version 0.8:

 - GSM audio parser

 - SMJPEG muxer

+- XWD encoder and decoder

 version 0.8_beta2:

@@ -379,6 +379,8 @@ following image formats are supported:

     @tab YUV, JPEG and some extension is not supported yet.

 @item Truevision Targa  @tab X @tab X

     @tab Targa (.TGA) image format

+@item XWD  @tab X @tab X

+    @tab X Window Dump image format

 @end multitable

 @code{X} means that encoding (resp. decoding) is supported.

@@ -435,6 +435,8 @@ OBJS-$(CONFIG_XAN_WC4_DECODER)         += xxan.o

 OBJS-$(CONFIG_XL_DECODER)              += xl.o

 OBJS-$(CONFIG_XSUB_DECODER)            += xsubdec.o

 OBJS-$(CONFIG_XSUB_ENCODER)            += xsubenc.o

+OBJS-$(CONFIG_XWD_DECODER)             += xwddec.o

+OBJS-$(CONFIG_XWD_ENCODER)             += xwdenc.o

 OBJS-$(CONFIG_YOP_DECODER)             += yop.o

 OBJS-$(CONFIG_ZLIB_DECODER)            += lcldec.o

 OBJS-$(CONFIG_ZLIB_ENCODER)            += lclenc.o

@@ -230,6 +230,7 @@ void avcodec_register_all(void)

     REGISTER_DECODER (XAN_WC3, xan_wc3);

     REGISTER_DECODER (XAN_WC4, xan_wc4);

     REGISTER_DECODER (XL, xl);

+    REGISTER_ENCDEC  (XWD, xwd);

     REGISTER_DECODER (YOP, yop);

     REGISTER_ENCDEC  (ZLIB, zlib);

     REGISTER_ENCDEC  (ZMBV, zmbv);

@@ -254,6 +254,7 @@ enum CodecID {

     CODEC_ID_VBLE,

     CODEC_ID_DXTORY,

     CODEC_ID_V410,

+    CODEC_ID_XWD,

     /* various PCM "codecs" */

     CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio codecs

@@ -21,7 +21,7 @@

 #define AVCODEC_VERSION_H

 #define LIBAVCODEC_VERSION_MAJOR 53

-#define LIBAVCODEC_VERSION_MINOR 34

+#define LIBAVCODEC_VERSION_MINOR 35

 #define LIBAVCODEC_VERSION_MICRO  0

 #define LIBAVCODEC_VERSION_INT  AV_VERSION_INT(LIBAVCODEC_VERSION_MAJOR, \

new file mode 100644

@@ -0,0 +1,41 @@

+/*

+ * XWD image format

+ *

+ * Copyright (c) 2012 Paul B Mahol

+ *

+ * This file is part of Libav.

+ *

+ * Libav 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.1 of the License, or (at your option) any later version.

+ *

+ * Libav 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 Libav; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#ifndef AVCODEC_XWD_H

+#define AVCODEC_XWD_H

+

+#define XWD_VERSION         7

+#define XWD_HEADER_SIZE     100

+#define XWD_CMAP_SIZE       12

+

+#define XWD_XY_BITMAP       0

+#define XWD_XY_PIXMAP       1

+#define XWD_Z_PIXMAP        2

+

+#define XWD_STATIC_GRAY     0

+#define XWD_GRAY_SCALE      1

+#define XWD_STATIC_COLOR    2

+#define XWD_PSEUDO_COLOR    3

+#define XWD_TRUE_COLOR      4

+#define XWD_DIRECT_COLOR    5

+

+#endif /* AVCODEC_XWD_H */

new file mode 100644

@@ -0,0 +1,267 @@

+/*

+ * XWD image format

+ *

+ * Copyright (c) 2012 Paul B Mahol

+ *

+ * This file is part of Libav.

+ *

+ * Libav 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.1 of the License, or (at your option) any later version.

+ *

+ * Libav 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 Libav; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#include "libavutil/imgutils.h"

+#include "avcodec.h"

+#include "bytestream.h"

+#include "xwd.h"

+

+static av_cold int xwd_decode_init(AVCodecContext *avctx)

+{

+    avctx->coded_frame = avcodec_alloc_frame();

+    if (!avctx->coded_frame)

+        return AVERROR(ENOMEM);

+

+    return 0;

+}

+

+static int xwd_decode_frame(AVCodecContext *avctx, void *data,

+                            int *data_size, AVPacket *avpkt)

+{

+    AVFrame *p = avctx->coded_frame;

+    const uint8_t *buf = avpkt->data;

+    int i, ret, buf_size = avpkt->size;

+    uint32_t version, header_size, vclass, ncolors;

+    uint32_t xoffset, be, bpp, lsize, rsize;

+    uint32_t pixformat, pixdepth, bunit, bitorder, bpad;

+    uint32_t rgb[3];

+    uint8_t *ptr;

+

+    if (buf_size < XWD_HEADER_SIZE)

+        return AVERROR_INVALIDDATA;

+

+    header_size = bytestream_get_be32(&buf);

+    if (buf_size < header_size)

+        return AVERROR_INVALIDDATA;

+

+    version = bytestream_get_be32(&buf);

+    if (version != XWD_VERSION) {

+        av_log(avctx, AV_LOG_ERROR, "unsupported version\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    if (header_size < XWD_HEADER_SIZE) {

+        av_log(avctx, AV_LOG_ERROR, "invalid header size\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    pixformat     = bytestream_get_be32(&buf);

+    pixdepth      = bytestream_get_be32(&buf);

+    avctx->width  = bytestream_get_be32(&buf);

+    avctx->height = bytestream_get_be32(&buf);

+    xoffset       = bytestream_get_be32(&buf);

+    be            = bytestream_get_be32(&buf);

+    bunit         = bytestream_get_be32(&buf);

+    bitorder      = bytestream_get_be32(&buf);

+    bpad          = bytestream_get_be32(&buf);

+    bpp           = bytestream_get_be32(&buf);

+    lsize         = bytestream_get_be32(&buf);

+    vclass        = bytestream_get_be32(&buf);

+    rgb[0]        = bytestream_get_be32(&buf);

+    rgb[1]        = bytestream_get_be32(&buf);

+    rgb[2]        = bytestream_get_be32(&buf);

+    buf          += 8;

+    ncolors       = bytestream_get_be32(&buf);

+    buf          += header_size - (XWD_HEADER_SIZE - 20);

+

+    av_log(avctx, AV_LOG_DEBUG, "pixformat %d, pixdepth %d, bunit %d, bitorder %d, bpad %d\n",

+           pixformat, pixdepth, bunit, bitorder, bpad);

+    av_log(avctx, AV_LOG_DEBUG, "vclass %d, ncolors %d, bpp %d, be %d, lsize %d, xoffset %d\n",

+           vclass, ncolors, bpp, be, lsize, xoffset);

+    av_log(avctx, AV_LOG_DEBUG, "red %0x, green %0x, blue %0x\n", rgb[0], rgb[1], rgb[2]);

+

+    if (pixformat > XWD_Z_PIXMAP) {

+        av_log(avctx, AV_LOG_ERROR, "invalid pixmap format\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    if (pixdepth == 0 || pixdepth > 32) {

+        av_log(avctx, AV_LOG_ERROR, "invalid pixmap depth\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    if (xoffset) {

+        av_log_ask_for_sample(avctx, "unsupported xoffset %d\n", xoffset);

+        return AVERROR_PATCHWELCOME;

+    }

+

+    if (be > 1) {

+        av_log(avctx, AV_LOG_ERROR, "invalid byte order\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    if (bitorder > 1) {

+        av_log(avctx, AV_LOG_ERROR, "invalid bitmap bit order\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    if (bunit != 8 && bunit != 16 && bunit != 32) {

+        av_log(avctx, AV_LOG_ERROR, "invalid bitmap unit\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    if (bpad != 8 && bpad != 16 && bpad != 32) {

+        av_log(avctx, AV_LOG_ERROR, "invalid bitmap scan-line pad\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    if (bpp == 0 || bpp > 32) {

+        av_log(avctx, AV_LOG_ERROR, "invalid bits per pixel\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    if (ncolors > 256) {

+        av_log(avctx, AV_LOG_ERROR, "invalid number of entries in colormap\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    if ((ret = av_image_check_size(avctx->width, avctx->height, 0, NULL)) < 0)

+        return ret;

+

+    rsize = FFALIGN(avctx->width * bpp, bpad) / 8;

+    if (lsize < rsize) {

+        av_log(avctx, AV_LOG_ERROR, "invalid bytes per scan-line\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    if (buf_size < header_size + ncolors * XWD_CMAP_SIZE + avctx->height * lsize) {

+        av_log(avctx, AV_LOG_ERROR, "input buffer too small\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    if (pixformat != XWD_Z_PIXMAP) {

+        av_log(avctx, AV_LOG_ERROR, "pixmap format %d unsupported\n", pixformat);

+        return AVERROR_PATCHWELCOME;

+    }

+

+    avctx->pix_fmt = PIX_FMT_NONE;

+    switch (vclass) {

+    case XWD_STATIC_GRAY:

+    case XWD_GRAY_SCALE:

+        if (bpp != 1)

+            return AVERROR_INVALIDDATA;

+        if (pixdepth == 1)

+            avctx->pix_fmt = PIX_FMT_MONOWHITE;

+        break;

+    case XWD_STATIC_COLOR:

+    case XWD_PSEUDO_COLOR:

+        if (bpp == 8)

+            avctx->pix_fmt = PIX_FMT_PAL8;

+        break;

+    case XWD_TRUE_COLOR:

+    case XWD_DIRECT_COLOR:

+        if (bpp != 16 && bpp != 24 && bpp != 32)

+            return AVERROR_INVALIDDATA;

+        if (bpp == 16 && pixdepth == 15) {

+            if (rgb[0] == 0x7C00 && rgb[1] == 0x3E0 && rgb[2] == 0x1F)

+                avctx->pix_fmt = be ? PIX_FMT_RGB555BE : PIX_FMT_RGB555LE;

+            else if (rgb[0] == 0x1F && rgb[1] == 0x3E0 && rgb[2] == 0x7C00)

+                avctx->pix_fmt = be ? PIX_FMT_BGR555BE : PIX_FMT_BGR555LE;

+        } else if (bpp == 16 && pixdepth == 16) {

+            if (rgb[0] == 0xF800 && rgb[1] == 0x7E0 && rgb[2] == 0x1F)

+                avctx->pix_fmt = be ? PIX_FMT_RGB565BE : PIX_FMT_RGB565LE;

+            else if (rgb[0] == 0x1F && rgb[1] == 0x7E0 && rgb[2] == 0xF800)

+                avctx->pix_fmt = be ? PIX_FMT_BGR565BE : PIX_FMT_BGR565LE;

+        } else if (bpp == 24) {

+            if (rgb[0] == 0xFF0000 && rgb[1] == 0xFF00 && rgb[2] == 0xFF)

+                avctx->pix_fmt = be ? PIX_FMT_RGB24 : PIX_FMT_BGR24;

+            else if (rgb[0] == 0xFF && rgb[1] == 0xFF00 && rgb[2] == 0xFF0000)

+                avctx->pix_fmt = be ? PIX_FMT_BGR24 : PIX_FMT_RGB24;

+        } else if (bpp == 32) {

+            if (rgb[0] == 0xFF0000 && rgb[1] == 0xFF00 && rgb[2] == 0xFF)

+                avctx->pix_fmt = be ? PIX_FMT_ARGB : PIX_FMT_BGRA;

+            else if (rgb[0] == 0xFF && rgb[1] == 0xFF00 && rgb[2] == 0xFF0000)

+                avctx->pix_fmt = be ? PIX_FMT_ABGR : PIX_FMT_RGBA;

+        }

+        buf += ncolors * XWD_CMAP_SIZE;

+        break;

+    default:

+        av_log(avctx, AV_LOG_ERROR, "invalid visual class\n");

+        return AVERROR_INVALIDDATA;

+    }

+

+    if (avctx->pix_fmt == PIX_FMT_NONE) {

+        av_log_ask_for_sample(avctx, "unknown file: bpp %d, pixdepth %d, vclass %d\n", bpp, pixdepth, vclass);

+        return AVERROR_PATCHWELCOME;

+    }

+

+    if (p->data[0])

+        avctx->release_buffer(avctx, p);

+

+    p->reference = 0;

+    if ((ret = avctx->get_buffer(avctx, p)) < 0) {

+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");

+        return ret;

+    }

+

+    p->key_frame = 1;

+    p->pict_type = AV_PICTURE_TYPE_I;

+

+    if (avctx->pix_fmt == PIX_FMT_PAL8) {

+        uint32_t *dst = (uint32_t *)p->data[1];

+        uint8_t red, green, blue;

+

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

+

+            buf   += 4;  // skip colormap entry number

+            red    = *buf; buf += 2;

+            green  = *buf; buf += 2;

+            blue   = *buf; buf += 2;

+            buf   += 2;  // skip bitmask flag and padding

+

+            dst[i] = red << 16 | green << 8 | blue;

+        }

+    }

+

+    ptr = p->data[0];

+    for (i = 0; i < avctx->height; i++) {

+        bytestream_get_buffer(&buf, ptr, rsize);

+        buf += lsize - rsize;

+        ptr += p->linesize[0];

+    }

+

+    *data_size = sizeof(AVFrame);

+    *(AVFrame *)data = *p;

+

+    return buf_size;

+}

+

+static av_cold int xwd_decode_close(AVCodecContext *avctx)

+{

+    if (avctx->coded_frame->data[0])

+        avctx->release_buffer(avctx, avctx->coded_frame);

+

+    av_freep(&avctx->coded_frame);

+

+    return 0;

+}

+

+AVCodec ff_xwd_decoder = {

+    .name           = "xwd",

+    .type           = AVMEDIA_TYPE_VIDEO,

+    .id             = CODEC_ID_XWD,

+    .init           = xwd_decode_init,

+    .close          = xwd_decode_close,

+    .decode         = xwd_decode_frame,

+    .capabilities   = CODEC_CAP_DR1,

+    .long_name      = NULL_IF_CONFIG_SMALL("XWD (X Window Dump) image"),

+};

new file mode 100644

@@ -0,0 +1,246 @@

+/*

+ * XWD image format

+ *

+ * Copyright (c) 2012 Paul B Mahol

+ *

+ * This file is part of Libav.

+ *

+ * Libav 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.1 of the License, or (at your option) any later version.

+ *

+ * Libav 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 Libav; if not, write to the Free Software

+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

+ */

+

+#include "libavutil/intreadwrite.h"

+#include "libavutil/pixdesc.h"

+#include "avcodec.h"

+#include "bytestream.h"

+#include "xwd.h"

+

+#define WINDOW_NAME         "lavcxwdenc"

+#define WINDOW_NAME_SIZE    11

+

+static av_cold int xwd_encode_init(AVCodecContext *avctx)

+{

+    avctx->coded_frame = avcodec_alloc_frame();

+    if (!avctx->coded_frame)

+        return AVERROR(ENOMEM);

+

+    return 0;

+}

+

+static int xwd_encode_frame(AVCodecContext *avctx, uint8_t *buf,

+                            int buf_size, void *data)

+{

+    AVFrame *p = data;

+    enum PixelFormat pix_fmt = avctx->pix_fmt;

+    uint32_t pixdepth, bpp, bpad, ncolors = 0, lsize, vclass, be = 0;

+    uint32_t rgb[3] = { 0 };

+    uint32_t header_size;

+    int i, out_size;

+    uint8_t *ptr;

+

+    pixdepth = av_get_bits_per_pixel(&av_pix_fmt_descriptors[pix_fmt]);

+    if (av_pix_fmt_descriptors[pix_fmt].flags & PIX_FMT_BE)

+        be = 1;

+    switch (pix_fmt) {

+    case PIX_FMT_ARGB:

+    case PIX_FMT_BGRA:

+    case PIX_FMT_RGBA:

+    case PIX_FMT_ABGR:

+        if (pix_fmt == PIX_FMT_ARGB ||

+            pix_fmt == PIX_FMT_ABGR)

+            be = 1;

+        if (pix_fmt == PIX_FMT_ABGR ||

+            pix_fmt == PIX_FMT_RGBA) {

+            rgb[0] = 0xFF;

+            rgb[1] = 0xFF00;

+            rgb[2] = 0xFF0000;

+        } else {

+            rgb[0] = 0xFF0000;

+            rgb[1] = 0xFF00;

+            rgb[2] = 0xFF;

+        }

+        bpp      = 32;

+        pixdepth = 24;

+        vclass   = XWD_TRUE_COLOR;

+        bpad     = 32;

+        break;

+    case PIX_FMT_BGR24:

+    case PIX_FMT_RGB24:

+        if (pix_fmt == PIX_FMT_RGB24)

+            be = 1;

+        bpp      = 24;

+        vclass   = XWD_TRUE_COLOR;

+        bpad     = 32;

+        rgb[0]   = 0xFF0000;

+        rgb[1]   = 0xFF00;

+        rgb[2]   = 0xFF;

+        break;

+    case PIX_FMT_RGB565LE:

+    case PIX_FMT_RGB565BE:

+    case PIX_FMT_BGR565LE:

+    case PIX_FMT_BGR565BE:

+        if (pix_fmt == PIX_FMT_BGR565LE ||

+            pix_fmt == PIX_FMT_BGR565BE) {

+            rgb[0] = 0x1F;

+            rgb[1] = 0x7E0;

+            rgb[2] = 0xF800;

+        } else {

+            rgb[0] = 0xF800;

+            rgb[1] = 0x7E0;

+            rgb[2] = 0x1F;

+        }

+        bpp      = 16;

+        vclass   = XWD_TRUE_COLOR;

+        bpad     = 16;

+        break;

+    case PIX_FMT_RGB555LE:

+    case PIX_FMT_RGB555BE:

+    case PIX_FMT_BGR555LE:

+    case PIX_FMT_BGR555BE:

+        if (pix_fmt == PIX_FMT_BGR555LE ||

+            pix_fmt == PIX_FMT_BGR555BE) {

+            rgb[0] = 0x1F;

+            rgb[1] = 0x3E0;

+            rgb[2] = 0x7C00;

+        } else {

+            rgb[0] = 0x7C00;

+            rgb[1] = 0x3E0;

+            rgb[2] = 0x1F;

+        }

+        bpp      = 16;

+        vclass   = XWD_TRUE_COLOR;

+        bpad     = 16;

+        break;

+    case PIX_FMT_RGB8:

+    case PIX_FMT_BGR8:

+    case PIX_FMT_RGB4_BYTE:

+    case PIX_FMT_BGR4_BYTE:

+    case PIX_FMT_PAL8:

+        bpp      = 8;

+        vclass   = XWD_PSEUDO_COLOR;

+        bpad     = 8;

+        ncolors  = 256;

+        break;

+    case PIX_FMT_MONOWHITE:

+        bpp      = 1;

+        bpad     = 8;

+        vclass   = XWD_STATIC_GRAY;

+        break;

+    default:

+        av_log(avctx, AV_LOG_INFO, "unsupported pixel format\n");

+        return AVERROR(EINVAL);

+    }

+

+    lsize       = FFALIGN(bpp * avctx->width, bpad) / 8;

+    header_size = XWD_HEADER_SIZE + WINDOW_NAME_SIZE;

+    out_size    = header_size + ncolors * XWD_CMAP_SIZE + avctx->height * lsize;

+

+    if (buf_size < out_size) {

+        av_log(avctx, AV_LOG_ERROR, "output buffer too small\n");

+        return AVERROR(ENOMEM);

+    }

+

+    avctx->coded_frame->key_frame = 1;

+    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;

+

+    bytestream_put_be32(&buf, header_size);

+    bytestream_put_be32(&buf, XWD_VERSION);   // file version

+    bytestream_put_be32(&buf, XWD_Z_PIXMAP);  // pixmap format

+    bytestream_put_be32(&buf, pixdepth);      // pixmap depth in pixels

+    bytestream_put_be32(&buf, avctx->width);  // pixmap width in pixels

+    bytestream_put_be32(&buf, avctx->height); // pixmap height in pixels

+    bytestream_put_be32(&buf, 0);             // bitmap x offset

+    bytestream_put_be32(&buf, be);            // byte order

+    bytestream_put_be32(&buf, 32);            // bitmap unit

+    bytestream_put_be32(&buf, be);            // bit-order of image data

+    bytestream_put_be32(&buf, bpad);          // bitmap scan-line pad in bits

+    bytestream_put_be32(&buf, bpp);           // bits per pixel

+    bytestream_put_be32(&buf, lsize);         // bytes per scan-line

+    bytestream_put_be32(&buf, vclass);        // visual class

+    bytestream_put_be32(&buf, rgb[0]);        // red mask

+    bytestream_put_be32(&buf, rgb[1]);        // green mask

+    bytestream_put_be32(&buf, rgb[2]);        // blue mask

+    bytestream_put_be32(&buf, 8);             // size of each bitmask in bits

+    bytestream_put_be32(&buf, ncolors);       // number of colors

+    bytestream_put_be32(&buf, ncolors);       // number of entries in color map

+    bytestream_put_be32(&buf, avctx->width);  // window width

+    bytestream_put_be32(&buf, avctx->height); // window height

+    bytestream_put_be32(&buf, 0);             // window upper left X coordinate

+    bytestream_put_be32(&buf, 0);             // window upper left Y coordinate

+    bytestream_put_be32(&buf, 0);             // window border width

+    bytestream_put_buffer(&buf, WINDOW_NAME, WINDOW_NAME_SIZE);

+

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

+        uint32_t val;

+        uint8_t red, green, blue;

+

+        val   = AV_RN32A(p->data[1] + i * 4);

+        red   = (val >> 16) & 0xFF;

+        green = (val >>  8) & 0xFF;

+        blue  =  val        & 0xFF;

+

+        bytestream_put_be32(&buf, i);         // colormap entry number

+        bytestream_put_be16(&buf, red   << 8);

+        bytestream_put_be16(&buf, green << 8);

+        bytestream_put_be16(&buf, blue  << 8);

+        bytestream_put_byte(&buf, 0x7);       // bitmask flag

+        bytestream_put_byte(&buf, 0);         // padding

+    }

+

+    ptr = p->data[0];

+    for (i = 0; i < avctx->height; i++) {

+        bytestream_put_buffer(&buf, ptr, lsize);

+        ptr += p->linesize[0];

+    }

+

+    return out_size;

+}

+

+static av_cold int xwd_encode_close(AVCodecContext *avctx)

+{

+    av_freep(&avctx->coded_frame);

+

+    return 0;

+}

+

+AVCodec ff_xwd_encoder = {

+    .name         = "xwd",

+    .type         = AVMEDIA_TYPE_VIDEO,

+    .id           = CODEC_ID_XWD,

+    .init         = xwd_encode_init,

+    .encode       = xwd_encode_frame,

+    .close        = xwd_encode_close,

+    .pix_fmts     = (const enum PixelFormat[]) { PIX_FMT_BGRA,

+                                                 PIX_FMT_RGBA,

+                                                 PIX_FMT_ARGB,

+                                                 PIX_FMT_ABGR,

+                                                 PIX_FMT_RGB24,

+                                                 PIX_FMT_BGR24,

+                                                 PIX_FMT_RGB565BE,

+                                                 PIX_FMT_RGB565LE,

+                                                 PIX_FMT_BGR565BE,

+                                                 PIX_FMT_BGR565LE,

+                                                 PIX_FMT_RGB555BE,

+                                                 PIX_FMT_RGB555LE,

+                                                 PIX_FMT_BGR555BE,

+                                                 PIX_FMT_BGR555LE,

+                                                 PIX_FMT_RGB8,

+                                                 PIX_FMT_BGR8,

+                                                 PIX_FMT_RGB4_BYTE,

+                                                 PIX_FMT_BGR4_BYTE,

+                                                 PIX_FMT_PAL8,

+                                                 PIX_FMT_MONOWHITE,

+                                                 PIX_FMT_NONE },

+    .long_name    = NULL_IF_CONFIG_SMALL("XWD (X Window Dump) image"),

+};

@@ -85,6 +85,7 @@ static const IdStrMap img_tags[] = {

     { CODEC_ID_JPEG2000  , "jpc"},

     { CODEC_ID_DPX       , "dpx"},

     { CODEC_ID_PICTOR    , "pic"},

+    { CODEC_ID_XWD       , "xwd"},

     { CODEC_ID_NONE      , NULL}

 };

@@ -501,7 +502,7 @@ AVOutputFormat ff_image2_muxer = {

     .name           = "image2",

     .long_name      = NULL_IF_CONFIG_SMALL("image2 sequence"),

     .extensions     = "bmp,dpx,jpeg,jpg,ljpg,pam,pbm,pcx,pgm,pgmyuv,png,"

-                      "ppm,sgi,tga,tif,tiff,jp2",

+                      "ppm,sgi,tga,tif,tiff,jp2,xwd",

     .priv_data_size = sizeof(VideoData),

     .video_codec    = CODEC_ID_MJPEG,

     .write_header   = write_header,