diff options
| -rw-r--r-- | Changelog | 1 | ||||
| -rw-r--r-- | doc/general.texi | 2 | ||||
| -rw-r--r-- | libavcodec/Makefile | 2 | ||||
| -rw-r--r-- | libavcodec/allcodecs.c | 1 | ||||
| -rw-r--r-- | libavcodec/avcodec.h | 1 | ||||
| -rw-r--r-- | libavcodec/version.h | 2 | ||||
| -rw-r--r-- | libavcodec/xwd.h | 41 | ||||
| -rw-r--r-- | libavcodec/xwddec.c | 267 | ||||
| -rw-r--r-- | libavcodec/xwdenc.c | 246 | ||||
| -rw-r--r-- | libavformat/img2.c | 3 |
10 files changed, 564 insertions, 2 deletions
@@ -6,6 +6,7 @@ version 0.8: - GSM audio parser - SMJPEG muxer +- XWD encoder and decoder version 0.8_beta2: diff --git a/doc/general.texi b/doc/general.texi index 79af887570..cda79c07b4 100644 --- a/doc/general.texi +++ b/doc/general.texi @@ -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. diff --git a/libavcodec/Makefile b/libavcodec/Makefile index 1e8d09b956..3468f66863 100644 --- a/libavcodec/Makefile +++ b/libavcodec/Makefile @@ -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 diff --git a/libavcodec/allcodecs.c b/libavcodec/allcodecs.c index 528969214e..d00bd0b79c 100644 --- a/libavcodec/allcodecs.c +++ b/libavcodec/allcodecs.c @@ -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); diff --git a/libavcodec/avcodec.h b/libavcodec/avcodec.h index be1b2021bd..967a134bdd 100644 --- a/libavcodec/avcodec.h +++ b/libavcodec/avcodec.h @@ -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 diff --git a/libavcodec/version.h b/libavcodec/version.h index c7b4c15b7a..77e16823f9 100644 --- a/libavcodec/version.h +++ b/libavcodec/version.h @@ -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, \ diff --git a/libavcodec/xwd.h b/libavcodec/xwd.h new file mode 100644 index 0000000000..f41e2cd651 --- /dev/null +++ b/libavcodec/xwd.h @@ -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 */ diff --git a/libavcodec/xwddec.c b/libavcodec/xwddec.c new file mode 100644 index 0000000000..97f3a6a979 --- /dev/null +++ b/libavcodec/xwddec.c @@ -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"), +}; diff --git a/libavcodec/xwdenc.c b/libavcodec/xwdenc.c new file mode 100644 index 0000000000..5bfdaf780a --- /dev/null +++ b/libavcodec/xwdenc.c @@ -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"), +}; diff --git a/libavformat/img2.c b/libavformat/img2.c index 2af561c2ce..e3e7d11e43 100644 --- a/libavformat/img2.c +++ b/libavformat/img2.c @@ -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, |