[deb_ffmpeg.git] / ffmpeg / libavcodec / xwdenc.c

/*
 * XWD image format
 *
 * Copyright (c) 2012 Paul B Mahol
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg 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.
 *
 * FFmpeg 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 FFmpeg; 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 "internal.h"
#include "xwd.h"

#define WINDOW_NAME         "lavcxwdenc"
#define WINDOW_NAME_SIZE    11

static int xwd_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                            const AVFrame *pict, int *got_packet)
{
    enum AVPixelFormat pix_fmt = avctx->pix_fmt;
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
    uint32_t pixdepth, bpp, bpad, ncolors = 0, lsize, vclass, be = 0;
    uint32_t rgb[3] = { 0 }, bitorder = 0;
    uint32_t header_size;
    int i, out_size, ret;
    uint8_t *ptr, *buf;
    AVFrame * const p = (AVFrame *)pict;

    pixdepth = av_get_bits_per_pixel(desc);
    if (desc->flags & AV_PIX_FMT_FLAG_BE)
        be = 1;
    switch (pix_fmt) {
    case AV_PIX_FMT_ARGB:
    case AV_PIX_FMT_BGRA:
    case AV_PIX_FMT_RGBA:
    case AV_PIX_FMT_ABGR:
        if (pix_fmt == AV_PIX_FMT_ARGB ||
            pix_fmt == AV_PIX_FMT_ABGR)
            be = 1;
        if (pix_fmt == AV_PIX_FMT_ABGR ||
            pix_fmt == AV_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 AV_PIX_FMT_BGR24:
    case AV_PIX_FMT_RGB24:
        if (pix_fmt == AV_PIX_FMT_RGB24)
            be = 1;
        bpp      = 24;
        vclass   = XWD_TRUE_COLOR;
        bpad     = 32;
        rgb[0]   = 0xFF0000;
        rgb[1]   = 0xFF00;
        rgb[2]   = 0xFF;
        break;
    case AV_PIX_FMT_RGB565LE:
    case AV_PIX_FMT_RGB565BE:
    case AV_PIX_FMT_BGR565LE:
    case AV_PIX_FMT_BGR565BE:
        if (pix_fmt == AV_PIX_FMT_BGR565LE ||
            pix_fmt == AV_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 AV_PIX_FMT_RGB555LE:
    case AV_PIX_FMT_RGB555BE:
    case AV_PIX_FMT_BGR555LE:
    case AV_PIX_FMT_BGR555BE:
        if (pix_fmt == AV_PIX_FMT_BGR555LE ||
            pix_fmt == AV_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 AV_PIX_FMT_RGB8:
    case AV_PIX_FMT_BGR8:
    case AV_PIX_FMT_RGB4_BYTE:
    case AV_PIX_FMT_BGR4_BYTE:
    case AV_PIX_FMT_PAL8:
        bpp      = 8;
        vclass   = XWD_PSEUDO_COLOR;
        bpad     = 8;
        ncolors  = 256;
        break;
    case AV_PIX_FMT_GRAY8:
        bpp      = 8;
        bpad     = 8;
        vclass   = XWD_STATIC_GRAY;
        break;
    case AV_PIX_FMT_MONOWHITE:
        be       = 1;
        bitorder = 1;
        bpp      = 1;
        bpad     = 8;
        vclass   = XWD_STATIC_GRAY;
        break;
    default:
        av_log(avctx, AV_LOG_ERROR, "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 ((ret = ff_alloc_packet2(avctx, pkt, out_size)) < 0)
        return ret;
    buf = pkt->data;

    p->key_frame = 1;
    p->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, bitorder);      // 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];
    }

    pkt->flags |= AV_PKT_FLAG_KEY;
    *got_packet = 1;
    return 0;
}

AVCodec ff_xwd_encoder = {
    .name         = "xwd",
    .long_name    = NULL_IF_CONFIG_SMALL("XWD (X Window Dump) image"),
    .type         = AVMEDIA_TYPE_VIDEO,
    .id           = AV_CODEC_ID_XWD,
    .encode2      = xwd_encode_frame,
    .pix_fmts     = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGRA,
                                                 AV_PIX_FMT_RGBA,
                                                 AV_PIX_FMT_ARGB,
                                                 AV_PIX_FMT_ABGR,
                                                 AV_PIX_FMT_RGB24,
                                                 AV_PIX_FMT_BGR24,
                                                 AV_PIX_FMT_RGB565BE,
                                                 AV_PIX_FMT_RGB565LE,
                                                 AV_PIX_FMT_BGR565BE,
                                                 AV_PIX_FMT_BGR565LE,
                                                 AV_PIX_FMT_RGB555BE,
                                                 AV_PIX_FMT_RGB555LE,
                                                 AV_PIX_FMT_BGR555BE,
                                                 AV_PIX_FMT_BGR555LE,
                                                 AV_PIX_FMT_RGB8,
                                                 AV_PIX_FMT_BGR8,
                                                 AV_PIX_FMT_RGB4_BYTE,
                                                 AV_PIX_FMT_BGR4_BYTE,
                                                 AV_PIX_FMT_PAL8,
                                                 AV_PIX_FMT_GRAY8,
                                                 AV_PIX_FMT_MONOWHITE,
                                                 AV_PIX_FMT_NONE },
};
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* XWD image format
	3	*
	4	* Copyright (c) 2012 Paul B Mahol
	5	*
	6	* This file is part of FFmpeg.
	7	*
	8	* FFmpeg is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License as published by the Free Software Foundation; either
	11	* version 2.1 of the License, or (at your option) any later version.
	12	*
	13	* FFmpeg is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* Lesser General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU Lesser General Public
	19	* License along with FFmpeg; if not, write to the Free Software
	20	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	21	*/
	22
	23	#include "libavutil/intreadwrite.h"
	24	#include "libavutil/pixdesc.h"
	25	#include "avcodec.h"
	26	#include "bytestream.h"
	27	#include "internal.h"
	28	#include "xwd.h"
	29
	30	#define WINDOW_NAME "lavcxwdenc"
	31	#define WINDOW_NAME_SIZE 11
	32
	33	static int xwd_encode_frame(AVCodecContext avctx, AVPacket pkt,
	34	const AVFrame pict, int got_packet)
	35	{
	36	enum AVPixelFormat pix_fmt = avctx->pix_fmt;
	37	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
	38	uint32_t pixdepth, bpp, bpad, ncolors = 0, lsize, vclass, be = 0;
	39	uint32_t rgb[3] = { 0 }, bitorder = 0;
	40	uint32_t header_size;
	41	int i, out_size, ret;
	42	uint8_t ptr, buf;
	43	AVFrame * const p = (AVFrame *)pict;
	44
	45	pixdepth = av_get_bits_per_pixel(desc);
	46	if (desc->flags & AV_PIX_FMT_FLAG_BE)
	47	be = 1;
	48	switch (pix_fmt) {
	49	case AV_PIX_FMT_ARGB:
	50	case AV_PIX_FMT_BGRA:
	51	case AV_PIX_FMT_RGBA:
	52	case AV_PIX_FMT_ABGR:
	53	if (pix_fmt == AV_PIX_FMT_ARGB \|\|
	54	pix_fmt == AV_PIX_FMT_ABGR)
	55	be = 1;
	56	if (pix_fmt == AV_PIX_FMT_ABGR \|\|
	57	pix_fmt == AV_PIX_FMT_RGBA) {
	58	rgb[0] = 0xFF;
	59	rgb[1] = 0xFF00;
	60	rgb[2] = 0xFF0000;
	61	} else {
	62	rgb[0] = 0xFF0000;
	63	rgb[1] = 0xFF00;
	64	rgb[2] = 0xFF;
65	}
66	bpp = 32;
67	pixdepth = 24;
68	vclass = XWD_TRUE_COLOR;
69	bpad = 32;
70	break;
71	case AV_PIX_FMT_BGR24:
72	case AV_PIX_FMT_RGB24:
73	if (pix_fmt == AV_PIX_FMT_RGB24)
74	be = 1;
75	bpp = 24;
76	vclass = XWD_TRUE_COLOR;
77	bpad = 32;
78	rgb[0] = 0xFF0000;
79	rgb[1] = 0xFF00;
80	rgb[2] = 0xFF;
81	break;
82	case AV_PIX_FMT_RGB565LE:
83	case AV_PIX_FMT_RGB565BE:
84	case AV_PIX_FMT_BGR565LE:
85	case AV_PIX_FMT_BGR565BE:
86	if (pix_fmt == AV_PIX_FMT_BGR565LE \|\|
87	pix_fmt == AV_PIX_FMT_BGR565BE) {
88	rgb[0] = 0x1F;
89	rgb[1] = 0x7E0;
90	rgb[2] = 0xF800;
91	} else {
92	rgb[0] = 0xF800;
93	rgb[1] = 0x7E0;
94	rgb[2] = 0x1F;
95	}
96	bpp = 16;
97	vclass = XWD_TRUE_COLOR;
98	bpad = 16;
99	break;
100	case AV_PIX_FMT_RGB555LE:
101	case AV_PIX_FMT_RGB555BE:
102	case AV_PIX_FMT_BGR555LE:
103	case AV_PIX_FMT_BGR555BE:
104	if (pix_fmt == AV_PIX_FMT_BGR555LE \|\|
105	pix_fmt == AV_PIX_FMT_BGR555BE) {
106	rgb[0] = 0x1F;
107	rgb[1] = 0x3E0;
108	rgb[2] = 0x7C00;
109	} else {
110	rgb[0] = 0x7C00;
111	rgb[1] = 0x3E0;
112	rgb[2] = 0x1F;
113	}
114	bpp = 16;
115	vclass = XWD_TRUE_COLOR;
116	bpad = 16;
117	break;
118	case AV_PIX_FMT_RGB8:
119	case AV_PIX_FMT_BGR8:
120	case AV_PIX_FMT_RGB4_BYTE:
121	case AV_PIX_FMT_BGR4_BYTE:
122	case AV_PIX_FMT_PAL8:
123	bpp = 8;
124	vclass = XWD_PSEUDO_COLOR;
125	bpad = 8;
126	ncolors = 256;
127	break;
128	case AV_PIX_FMT_GRAY8:
129	bpp = 8;
130	bpad = 8;
131	vclass = XWD_STATIC_GRAY;
132	break;
133	case AV_PIX_FMT_MONOWHITE:
134	be = 1;
135	bitorder = 1;
136	bpp = 1;
137	bpad = 8;
138	vclass = XWD_STATIC_GRAY;
139	break;
140	default:
141	av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
142	return AVERROR(EINVAL);
143	}
144
145	lsize = FFALIGN(bpp * avctx->width, bpad) / 8;
146	header_size = XWD_HEADER_SIZE + WINDOW_NAME_SIZE;
147	out_size = header_size + ncolors * XWD_CMAP_SIZE + avctx->height * lsize;
148
149	if ((ret = ff_alloc_packet2(avctx, pkt, out_size)) < 0)
150	return ret;
151	buf = pkt->data;
152
153	p->key_frame = 1;
154	p->pict_type = AV_PICTURE_TYPE_I;
155
156	bytestream_put_be32(&buf, header_size);
157	bytestream_put_be32(&buf, XWD_VERSION); // file version
158	bytestream_put_be32(&buf, XWD_Z_PIXMAP); // pixmap format
159	bytestream_put_be32(&buf, pixdepth); // pixmap depth in pixels
160	bytestream_put_be32(&buf, avctx->width); // pixmap width in pixels
161	bytestream_put_be32(&buf, avctx->height); // pixmap height in pixels
162	bytestream_put_be32(&buf, 0); // bitmap x offset
163	bytestream_put_be32(&buf, be); // byte order
164	bytestream_put_be32(&buf, 32); // bitmap unit
165	bytestream_put_be32(&buf, bitorder); // bit-order of image data
166	bytestream_put_be32(&buf, bpad); // bitmap scan-line pad in bits
167	bytestream_put_be32(&buf, bpp); // bits per pixel
168	bytestream_put_be32(&buf, lsize); // bytes per scan-line
169	bytestream_put_be32(&buf, vclass); // visual class
170	bytestream_put_be32(&buf, rgb[0]); // red mask
171	bytestream_put_be32(&buf, rgb[1]); // green mask
172	bytestream_put_be32(&buf, rgb[2]); // blue mask
173	bytestream_put_be32(&buf, 8); // size of each bitmask in bits
174	bytestream_put_be32(&buf, ncolors); // number of colors
175	bytestream_put_be32(&buf, ncolors); // number of entries in color map
176	bytestream_put_be32(&buf, avctx->width); // window width
177	bytestream_put_be32(&buf, avctx->height); // window height
178	bytestream_put_be32(&buf, 0); // window upper left X coordinate
179	bytestream_put_be32(&buf, 0); // window upper left Y coordinate
180	bytestream_put_be32(&buf, 0); // window border width
181	bytestream_put_buffer(&buf, WINDOW_NAME, WINDOW_NAME_SIZE);
182
183	for (i = 0; i < ncolors; i++) {
184	uint32_t val;
185	uint8_t red, green, blue;
186
187	val = AV_RN32A(p->data[1] + i * 4);
188	red = (val >> 16) & 0xFF;
189	green = (val >> 8) & 0xFF;
190	blue = val & 0xFF;
191
192	bytestream_put_be32(&buf, i); // colormap entry number
193	bytestream_put_be16(&buf, red << 8);
194	bytestream_put_be16(&buf, green << 8);
195	bytestream_put_be16(&buf, blue << 8);
196	bytestream_put_byte(&buf, 0x7); // bitmask flag
197	bytestream_put_byte(&buf, 0); // padding
198	}
199
200	ptr = p->data[0];
201	for (i = 0; i < avctx->height; i++) {
202	bytestream_put_buffer(&buf, ptr, lsize);
203	ptr += p->linesize[0];
204	}
205
206	pkt->flags \|= AV_PKT_FLAG_KEY;
207	*got_packet = 1;
208	return 0;
209	}
210
211	AVCodec ff_xwd_encoder = {
212	.name = "xwd",
213	.long_name = NULL_IF_CONFIG_SMALL("XWD (X Window Dump) image"),
214	.type = AVMEDIA_TYPE_VIDEO,
215	.id = AV_CODEC_ID_XWD,
216	.encode2 = xwd_encode_frame,
217	.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGRA,
218	AV_PIX_FMT_RGBA,
219	AV_PIX_FMT_ARGB,
220	AV_PIX_FMT_ABGR,
221	AV_PIX_FMT_RGB24,
222	AV_PIX_FMT_BGR24,
223	AV_PIX_FMT_RGB565BE,
224	AV_PIX_FMT_RGB565LE,
225	AV_PIX_FMT_BGR565BE,
226	AV_PIX_FMT_BGR565LE,
227	AV_PIX_FMT_RGB555BE,
228	AV_PIX_FMT_RGB555LE,
229	AV_PIX_FMT_BGR555BE,
230	AV_PIX_FMT_BGR555LE,
231	AV_PIX_FMT_RGB8,
232	AV_PIX_FMT_BGR8,
233	AV_PIX_FMT_RGB4_BYTE,
234	AV_PIX_FMT_BGR4_BYTE,
235	AV_PIX_FMT_PAL8,
236	AV_PIX_FMT_GRAY8,
237	AV_PIX_FMT_MONOWHITE,
238	AV_PIX_FMT_NONE },
239	};