[ViewVC] Diff of: cvs/rxvt-unicode/src/rxvtimg.C

Comparing rxvt-unicode/src/rxvtimg.C (file contents):
Revision 1.7 by sf-exg, Sun Jun 3 20:34:25 2012 UTC vs.
Revision 1.102 by root, Sat Jul 7 07:00:17 2012 UTC

…		…
		1	/----------------------------------------------------------------------
		2	* File: rxvtimg.C
		3	----------------------------------------------------------------------
		4	*
		5	* All portions of code are copyright by their respective author/s.
		6	* Copyright (c) 2012 Marc Lehmann <schmorp@schmorp.de>
		7	* Copyright (c) 2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
		8	*
		9	* This program is free software; you can redistribute it and/or modify
		10	* it under the terms of the GNU General Public License as published by
		11	* the Free Software Foundation; either version 2 of the License, or
		12	* (at your option) any later version.
		13	*
		14	* This program is distributed in the hope that it will be useful,
		15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		17	* GNU General Public License for more details.
		18	*
		19	* You should have received a copy of the GNU General Public License
		20	* along with this program; if not, write to the Free Software
		21	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
		22	---------------------------------------------------------------------/
		23
		24	#include <string.h>
1	#include <math.h>	25	#include <math.h>
2	#include "../config.h"	26	#include "../config.h"
3	#include "rxvt.h"	27	#include "rxvt.h"
4		28
5	#if HAVE_IMG	29	#if HAVE_IMG
6		30
7	#define float_to_component(d) ((d) * 65535.99)	31	typedef rxvt_img::nv nv;
8		32
		33	namespace
		34	{
		35	struct mat3x3
		36	{
		37	nv v[3][3];
		38
		39	mat3x3 ()
		40	{
		41	}
		42
		43	mat3x3 (const nv *matrix)
		44	{
		45	memcpy (v, matrix, sizeof (v));
		46	}
		47
		48	mat3x3 (nv v11, nv v12, nv v13, nv v21, nv v22, nv v23, nv v31, nv v32, nv v33)
		49	{
		50	v[0][0] = v11; v[0][1] = v12; v[0][2] = v13;
		51	v[1][0] = v21; v[1][1] = v22; v[1][2] = v23;
		52	v[2][0] = v31; v[2][1] = v32; v[2][2] = v33;
		53	}
		54
		55	mat3x3 inverse ();
		56
		57	nv *operator [](int i) { return &v[i][0]; }
		58	const nv *operator [](int i) const { return &v[i][0]; }
		59
		60	operator const nv * () const { return &v[0][0]; }
		61	operator nv * () { return &v[0][0]; }
		62
		63	// quite inefficient, hopefully gcc pulls the w calc out of any loops
		64	nv apply1 (int i, nv x, nv y)
		65	{
		66	mat3x3 &m = *this;
		67
		68	nv v = m[i][0] * x + m[i][1] * y + m[i][2];
		69	nv w = m[2][0] * x + m[2][1] * y + m[2][2];
		70
		71	return v * (1. / w);
		72	}
		73
		74	static mat3x3 translate (nv x, nv y);
		75	static mat3x3 scale (nv s, nv t);
		76	static mat3x3 rotate (nv phi);
		77	};
		78
		79	mat3x3
		80	mat3x3::inverse ()
		81	{
		82	mat3x3 &m = *this;
		83	mat3x3 inv;
		84
		85	nv s0 = m[2][2] * m[1][1] - m[2][1] * m[1][2];
		86	nv s1 = m[2][1] * m[0][2] - m[2][2] * m[0][1];
		87	nv s2 = m[1][2] * m[0][1] - m[1][1] * m[0][2];
		88
		89	nv invdet = 1. / (m[0][0] * s0 + m[1][0] * s1 + m[2][0] * s2);
		90
		91	inv[0][0] = invdet * s0;
		92	inv[0][1] = invdet * s1;
		93	inv[0][2] = invdet * s2;
		94
		95	inv[1][0] = invdet * (m[2][0] * m[1][2] - m[2][2] * m[1][0]);
		96	inv[1][1] = invdet * (m[2][2] * m[0][0] - m[2][0] * m[0][2]);
		97	inv[1][2] = invdet * (m[1][0] * m[0][2] - m[1][2] * m[0][0]);
		98
		99	inv[2][0] = invdet * (m[2][1] * m[1][0] - m[2][0] * m[1][1]);
		100	inv[2][1] = invdet * (m[2][0] * m[0][1] - m[2][1] * m[0][0]);
		101	inv[2][2] = invdet * (m[1][1] * m[0][0] - m[1][0] * m[0][1]);
		102
		103	return inv;
		104	}
		105
		106	static mat3x3
		107	operator *(const mat3x3 &a, const mat3x3 &b)
		108	{
		109	mat3x3 r;
		110
		111	for (int i = 0; i < 3; ++i)
		112	for (int j = 0; j < 3; ++j)
		113	r[i][j] = a[i][0] * b[0][j]
		114	+ a[i][1] * b[1][j]
		115	+ a[i][2] * b[2][j];
		116
		117	return r;
		118	}
		119
		120	mat3x3
		121	mat3x3::translate (nv x, nv y)
		122	{
		123	return mat3x3 (
		124	1, 0, x,
		125	0, 1, y,
		126	0, 0, 1
		127	);
		128	}
		129
		130	mat3x3
		131	mat3x3::scale (nv s, nv t)
		132	{
		133	return mat3x3 (
		134	s, 0, 0,
		135	0, t, 0,
		136	0, 0, 1
		137	);
		138	}
		139
		140	// clockwise
		141	mat3x3
		142	mat3x3::rotate (nv phi)
		143	{
		144	nv s = sin (phi);
		145	nv c = cos (phi);
		146
		147	return mat3x3 (
		148	c, -s, 0,
		149	s, c, 0,
		150	0, 0, 1
		151	);
		152	}
		153
		154	struct composer
		155	{
		156	rxvt_img srcimg, dstimg;
		157	Picture src, dst, msk;
		158	Display *dpy;
		159
		160	ecb_noinline
		161	composer (rxvt_img srcimg, rxvt_img dstimg = 0)
		162	: srcimg (srcimg), dstimg (dstimg), msk (0)
		163	{
		164	if (!this->dstimg)
		165	this->dstimg = srcimg->new_empty ();
		166	else if (!this->dstimg->pm) // somewhat unsatisfying
		167	this->dstimg->alloc ();
		168
		169	dpy = srcimg->s->dpy;
		170	src = srcimg->picture ();
		171	dst = this->dstimg->picture ();
		172	}
		173
		174	ecb_noinline
		175	void mask (bool rgb = true, int w = 1, int h = 1)
		176	{
		177	Pixmap pixmap = XCreatePixmap (dpy, srcimg->pm, w, h, rgb ? 32 : 8);
		178
		179	XRenderPictFormat *format = XRenderFindStandardFormat (dpy, rgb ? PictStandardARGB32 : PictStandardA8);
		180	XRenderPictureAttributes pa;
		181	pa.repeat = RepeatNormal;
		182	pa.component_alpha = rgb;
		183	msk = XRenderCreatePicture (dpy, pixmap, format, CPRepeat \| CPComponentAlpha, &pa);
		184
		185	XFreePixmap (dpy, pixmap);
		186
		187	ecb_assume (msk);
		188	}
		189
		190	// CreateSolidFill creates a very very very weird picture
		191	void mask (const rgba &c)
		192	{
		193	XRenderColor rc = {
		194	c.r * c.a / 65535,
		195	c.g * c.a / 65535,
		196	c.b * c.a / 65535,
		197	c.a
		198	};
		199	msk = XRenderCreateSolidFill (dpy, &rc);
		200	ecb_assume (msk);
		201	}
		202
		203	void fill (const rgba &c)
		204	{
		205	XRenderColor rc = {
		206	c.r * c.a / 65535,
		207	c.g * c.a / 65535,
		208	c.b * c.a / 65535,
		209	c.a
		210	};
		211
		212	XRenderFillRectangle (dpy, PictOpSrc, msk, &rc, 0, 0, 1, 1);
		213	}
		214
		215	operator rxvt_img *()
		216	{
		217	return dstimg;
		218	}
		219
		220	ecb_noinline
		221	~composer ()
		222	{
		223	XRenderFreePicture (dpy, src);
		224	XRenderFreePicture (dpy, dst);
		225	if (msk) XRenderFreePicture (dpy, msk);
		226	}
		227	};
		228	}
		229
		230	static XRenderPictFormat *
		231	find_alpha_format_for (Display dpy, XRenderPictFormat format)
		232	{
		233	if (format->direct.alphaMask)
		234	return format; // already has alpha
		235
		236	// try to find a suitable alpha format, one bit alpha is enough for our purposes
		237	if (format->type == PictTypeDirect)
		238	for (int n = 0; XRenderPictFormat *f = XRenderFindFormat (dpy, 0, 0, n); ++n)
		239	if (f->direct.alphaMask
		240	&& f->type == PictTypeDirect
		241	&& ecb_popcount32 (f->direct.redMask ) >= ecb_popcount32 (format->direct.redMask )
		242	&& ecb_popcount32 (f->direct.greenMask) >= ecb_popcount32 (format->direct.greenMask)
		243	&& ecb_popcount32 (f->direct.blueMask ) >= ecb_popcount32 (format->direct.blueMask ))
		244	return f;
		245
		246	// should be a very good fallback
		247	return XRenderFindStandardFormat (dpy, PictStandardARGB32);
		248	}
		249
9	rxvt_img::rxvt_img (rxvt_screen screen, XRenderPictFormat format, int width, int height)	250	rxvt_img::rxvt_img (rxvt_screen screen, XRenderPictFormat format, int x, int y, int width, int height, int repeat)
10	: s(screen), w(width), h(height), format(format), shared(false)
11	{
12	pm = XCreatePixmap (s->display->dpy, s->display->root, w, h, format->depth);
13	}
14
15	rxvt_img::rxvt_img (rxvt_screen screen, XRenderPictFormat format, int width, int height, Pixmap pixmap)
16	: s(screen), pm(pixmap), w(width), h(height), format(format), shared(false)	251	: s(screen), x(x), y(y), w(width), h(height), format(format), repeat(repeat),
		252	pm(0), ref(0)
17	{	253	{
18	}	254	}
19		255
20	rxvt_img *	256	rxvt_img::rxvt_img (const rxvt_img &img)
21	rxvt_img::new_from_file (rxvt_screen s, const char filename)	257	: s(img.s), x(img.x), y(img.y), w(img.w), h(img.h), format(img.format), repeat(img.repeat), pm(img.pm), ref(img.ref)
22	{	258	{
23	GError *err;	259	++ref->cnt;
24	GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err);	260	}
25		261
26	if (!pb)	262	rxvt_img *
		263	rxvt_img::new_from_root (rxvt_screen *s)
		264	{
		265	Display *dpy = s->dpy;
		266	unsigned int root_pm_w, root_pm_h;
		267	Pixmap root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_XROOTPMAP_ID]);
		268	if (root_pixmap == None)
		269	root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_ESETROOT_PMAP_ID]);
		270
		271	if (root_pixmap == None)
		272	return 0;
		273
		274	Window wdummy;
		275	int idummy;
		276	unsigned int udummy;
		277
		278	if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pm_w, &root_pm_h, &udummy, &udummy))
27	return 0;	279	return 0;
28		280
29	rxvt_img *img = new rxvt_img (	281	rxvt_img *img = new rxvt_img (
30	s,	282	s,
31	XRenderFindStandardFormat (s->display->dpy, gdk_pixbuf_get_has_alpha (pb) ? PictStandardARGB32 : PictStandardRGB24),	283	XRenderFindVisualFormat (dpy, DefaultVisual (dpy, s->display->screen)),
32	gdk_pixbuf_get_width (pb),	284	0,
33	gdk_pixbuf_get_height (pb)	285	0,
		286	root_pm_w,
		287	root_pm_h
34	);	288	);
35		289
36	img->render (pb, 0, 0, img->w, img->h, 0, 0);	290	img->pm = root_pixmap;
		291	img->ref = new pixref (root_pm_w, root_pm_h);
		292	img->ref->ours = false;
37		293
38	return img;	294	return img;
39	}	295	}
40		296
		297	# if HAVE_PIXBUF
		298
		299	rxvt_img *
		300	rxvt_img::new_from_pixbuf (rxvt_screen s, GdkPixbuf pb)
		301	{
		302	Display *dpy = s->dpy;
		303
		304	int width = gdk_pixbuf_get_width (pb);
		305	int height = gdk_pixbuf_get_height (pb);
		306
		307	if (width > 32767 \|\| height > 32767) // well, we could upload in chunks
		308	rxvt_fatal ("rxvt_img::new_from_pixbuf: image too big (maximum size 32768x32768).\n");
		309
		310	// since we require rgb24/argb32 formats from xrender we assume
		311	// that both 24 and 32 bpp MUST be supported by any screen that supports xrender
		312
		313	int byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
		314
		315	XImage xi;
		316
		317	xi.width = width;
		318	xi.height = height;
		319	xi.xoffset = 0;
		320	xi.format = ZPixmap;
		321	xi.byte_order = ImageByteOrder (dpy);
		322	xi.bitmap_unit = 0; //XY only, unused
		323	xi.bitmap_bit_order = 0; //XY only, unused
		324	xi.bitmap_pad = BitmapPad (dpy);
		325	xi.depth = 32;
		326	xi.bytes_per_line = 0;
		327	xi.bits_per_pixel = 32; //Z only
		328	xi.red_mask = 0x00000000; //Z only, unused
		329	xi.green_mask = 0x00000000; //Z only, unused
		330	xi.blue_mask = 0x00000000; //Z only, unused
		331	xi.obdata = 0; // probably unused
		332
		333	bool byte_order_mismatch = byte_order != xi.byte_order;
		334
		335	if (!XInitImage (&xi))
		336	rxvt_fatal ("unable to initialise ximage, please report.\n");
		337
		338	if (height > INT_MAX / xi.bytes_per_line)
		339	rxvt_fatal ("rxvt_img::new_from_pixbuf: image too big for Xlib.\n");
		340
		341	xi.data = (char )rxvt_malloc (height xi.bytes_per_line);
		342
		343	int rowstride = gdk_pixbuf_get_rowstride (pb);
		344	bool pb_has_alpha = gdk_pixbuf_get_has_alpha (pb);
		345	unsigned char *row = gdk_pixbuf_get_pixels (pb);
		346
		347	char *line = xi.data;
		348
		349	for (int y = 0; y < height; y++)
		350	{
		351	unsigned char *src = row;
		352	uint32_t dst = (uint32_t )line;
		353
		354	if (!pb_has_alpha)
		355	for (int x = 0; x < width; x++)
		356	{
		357	uint8_t r = *src++;
		358	uint8_t g = *src++;
		359	uint8_t b = *src++;
		360
		361	uint32_t v = (255 << 24) \| (r << 16) \| (g << 8) \| b;
		362
		363	if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch)
		364	v = ecb_bswap32 (v);
		365
		366	*dst++ = v;
		367	}
		368	else
		369	for (int x = 0; x < width; x++)
		370	{
		371	uint32_t v = (uint32_t )src; src += 4;
		372
		373	if (ecb_big_endian ())
		374	v = ecb_bswap32 (v);
		375
		376	v = ecb_rotl32 (v, 8); // abgr to bgra
		377
		378	if (!byte_order_mismatch)
		379	v = ecb_bswap32 (v);
		380
		381	*dst++ = v;
		382	}
		383
		384	row += rowstride;
		385	line += xi.bytes_per_line;
		386	}
		387
		388	rxvt_img *img = new rxvt_img (s, XRenderFindStandardFormat (dpy, PictStandardARGB32), 0, 0, width, height);
		389	img->alloc ();
		390
		391	GC gc = XCreateGC (dpy, img->pm, 0, 0);
		392	XPutImage (dpy, img->pm, gc, &xi, 0, 0, 0, 0, width, height);
		393	XFreeGC (dpy, gc);
		394
		395	free (xi.data);
		396
		397	return img;
		398	}
		399
		400	rxvt_img *
		401	rxvt_img::new_from_file (rxvt_screen s, const char filename)
		402	{
		403	GError *err = 0;
		404	GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err);
		405
		406	if (!pb)
		407	rxvt_fatal ("rxvt_img::new_from_file: %s\n", err->message);
		408
		409	rxvt_img *img = new_from_pixbuf (s, pb);
		410
		411	g_object_unref (pb);
		412
		413	return img;
		414	}
		415
		416	# endif
		417
		418	void
		419	rxvt_img::destroy ()
		420	{
		421	if (--ref->cnt)
		422	return;
		423
		424	if (pm && ref->ours)
		425	XFreePixmap (s->dpy, pm);
		426
		427	delete ref;
		428	}
		429
41	rxvt_img::~rxvt_img ()	430	rxvt_img::~rxvt_img ()
42	{	431	{
43	if (!shared)	432	destroy ();
44	XFreePixmap (s->display->dpy, pm);
45	}	433	}
46		434
47	void	435	void
48	rxvt_img::fill (const rxvt_color &c)	436	rxvt_img::alloc ()
49	{	437	{
50	XGCValues gcv;	438	pm = XCreatePixmap (s->dpy, s->display->root, w, h, format->depth);
51	gcv.foreground = c;	439	ref = new pixref (w, h);
52	GC gc = XCreateGC (s->display->dpy, pm, GCForeground, &gcv);	440	}
53	XFillRectangle (s->display->dpy, pm, gc, 0, 0, w, h);	441
		442	rxvt_img *
		443	rxvt_img::new_empty ()
		444	{
		445	rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat);
		446	img->alloc ();
		447
		448	return img;
		449	}
		450
		451	Picture
		452	rxvt_img::picture ()
		453	{
		454	Display *dpy = s->dpy;
		455
		456	XRenderPictureAttributes pa;
		457	pa.repeat = repeat;
		458	Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
		459
		460	return pic;
		461	}
		462
		463	void
		464	rxvt_img::unshare ()
		465	{
		466	if (ref->cnt == 1 && ref->ours)
		467	return;
		468
		469	Pixmap pm2 = XCreatePixmap (s->dpy, s->display->root, ref->w, ref->h, format->depth);
		470	GC gc = XCreateGC (s->dpy, pm, 0, 0);
		471	XCopyArea (s->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);
54	XFreeGC (s->display->dpy, gc);	472	XFreeGC (s->dpy, gc);
		473
		474	destroy ();
		475
		476	pm = pm2;
		477	ref = new pixref (ref->w, ref->h);
		478	}
		479
		480	void
		481	rxvt_img::fill (const rgba &c, int x, int y, int w, int h)
		482	{
		483	XRenderColor rc = { c.r, c.g, c.b, c.a };
		484
		485	Display *dpy = s->dpy;
		486	Picture src = picture ();
		487	XRenderFillRectangle (dpy, PictOpSrc, src, &rc, x, y, w, h);
		488	XRenderFreePicture (dpy, src);
		489	}
		490
		491	void
		492	rxvt_img::fill (const rgba &c)
		493	{
		494	fill (c, 0, 0, w, h);
		495	}
		496
		497	void
		498	rxvt_img::add_alpha ()
		499	{
		500	if (format->direct.alphaMask)
		501	return;
		502
		503	composer cc (this, new rxvt_img (s, find_alpha_format_for (s->dpy, format), x, y, w, h, repeat));
		504
		505	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
		506
		507	rxvt_img *img = cc;
		508
		509	::swap (img->ref, ref);
		510	::swap (img->pm , pm );
		511
		512	delete img;
55	}	513	}
56		514
57	static void	515	static void
58	get_gaussian_kernel (int radius, int width, double kernel, XFixed params)	516	get_gaussian_kernel (int radius, int width, nv kernel, XFixed params)
59	{	517	{
60	double sigma = radius / 2.0;	518	nv sigma = radius / 2.0;
61	double scale = sqrt (2.0 * M_PI) * sigma;	519	nv scale = sqrt (2.0 * M_PI) * sigma;
62	double sum = 0.0;	520	nv sum = 0.0;
63		521
64	for (int i = 0; i < width; i++)	522	for (int i = 0; i < width; i++)
65	{	523	{
66	double x = i - width / 2;	524	nv x = i - width / 2;
67	kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;	525	kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;
68	sum += kernel[i];	526	sum += kernel[i];
69	}	527	}
70		528
71	params[0] = XDoubleToFixed (width);	529	params[0] = XDoubleToFixed (width);
73		531
74	for (int i = 0; i < width; i++)	532	for (int i = 0; i < width; i++)
75	params[i+2] = XDoubleToFixed (kernel[i] / sum);	533	params[i+2] = XDoubleToFixed (kernel[i] / sum);
76	}	534	}
77		535
78	void	536	rxvt_img *
79	rxvt_img::blur (int rh, int rv)	537	rxvt_img::blur (int rh, int rv)
80	{	538	{
81	if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))	539	if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))
82	return;	540	return clone ();
83		541
84	Display *dpy = s->display->dpy;	542	Display *dpy = s->dpy;
85	int size = max (rh, rv) * 2 + 1;	543	int size = max (rh, rv) * 2 + 1;
86	double kernel = (double )malloc (size * sizeof (double));	544	nv kernel = (nv )malloc (size * sizeof (nv));
87	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	545	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
		546	rxvt_img *img = new_empty ();
88		547
89	XRenderPictureAttributes pa;	548	XRenderPictureAttributes pa;
90
91	pa.repeat = RepeatPad;	549	pa.repeat = RepeatPad;
92	Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);	550	Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
		551	Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
		552
93	Pixmap tmp = XCreatePixmap (dpy, pm, w, h, format->depth);	553	Pixmap tmp_pm = XCreatePixmap (dpy, pm, w, h, format->depth);
94	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);	554	Picture tmp = XRenderCreatePicture (dpy, tmp_pm , format, CPRepeat, &pa);
95	XFreePixmap (dpy, tmp);	555	XFreePixmap (dpy, tmp_pm);
96		556
97	if (kernel && params)	557	if (kernel && params)
98	{	558	{
99	size = rh * 2 + 1;	559	size = rh * 2 + 1;
100	get_gaussian_kernel (rh, size, kernel, params);	560	get_gaussian_kernel (rh, size, kernel, params);
101		561
102	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	562	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
103	XRenderComposite (dpy,	563	XRenderComposite (dpy,
104	PictOpSrc,	564	PictOpSrc,
105	src,	565	src,
		566	None,
		567	tmp,
		568	0, 0,
		569	0, 0,
		570	0, 0,
		571	w, h);
		572
		573	size = rv * 2 + 1;
		574	get_gaussian_kernel (rv, size, kernel, params);
		575	::swap (params[0], params[1]);
		576
		577	XRenderSetPictureFilter (dpy, tmp, FilterConvolution, params, size+2);
		578	XRenderComposite (dpy,
		579	PictOpSrc,
		580	tmp,
106	None,	581	None,
107	dst,	582	dst,
108	0, 0,	583	0, 0,
109	0, 0,	584	0, 0,
110	0, 0,	585	0, 0,
111	w, h);	586	w, h);
112
113	::swap (src, dst);
114
115	size = rv * 2 + 1;
116	get_gaussian_kernel (rv, size, kernel, params);
117	::swap (params[0], params[1]);
118
119	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
120	XRenderComposite (dpy,
121	PictOpSrc,
122	src,
123	None,
124	dst,
125	0, 0,
126	0, 0,
127	0, 0,
128	w, h);
129	}	587	}
130		588
131	free (kernel);	589	free (kernel);
132	free (params);	590	free (params);
		591
133	XRenderFreePicture (dpy, src);	592	XRenderFreePicture (dpy, src);
134	XRenderFreePicture (dpy, dst);	593	XRenderFreePicture (dpy, dst);
135	}	594	XRenderFreePicture (dpy, tmp);
136		595
137	static Picture
138	create_xrender_mask (Display *dpy, Drawable drawable, Bool argb)
139	{
140	Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
141
142	XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
143	XRenderPictureAttributes pa;
144	pa.repeat = True;
145	Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
146
147	XFreePixmap (dpy, pixmap);
148
149	return mask;	596	return img;
		597	}
		598
		599	rxvt_img *
		600	rxvt_img::muladd (nv mul, nv add)
		601	{
		602	// STEP 1: double the image width, fill all odd columns with white (==1)
		603
		604	composer cc (this, new rxvt_img (s, format, 0, 0, w * 2, h, repeat));
		605
		606	// why the hell does XRenderSetPictureTransform want a writable matrix :(
		607	// that keeps us from just static const'ing this matrix.
		608	XTransform h_double = {
		609	32768, 0, 0,
		610	0, 65536, 0,
		611	0, 0, 65536
		612	};
		613
		614	XRenderSetPictureFilter (cc.dpy, cc.src, "nearest", 0, 0);
		615	XRenderSetPictureTransform (cc.dpy, cc.src, &h_double);
		616	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
		617
		618	cc.mask (false, 2, 1);
		619
		620	static const XRenderColor c0 = { 0, 0, 0, 0 };
		621	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c0, 0, 0, 1, 1);
		622	static const XRenderColor c1 = { 65535, 65535, 65535, 65535 };
		623	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c1, 1, 0, 1, 1);
		624
		625	Picture white = XRenderCreateSolidFill (cc.dpy, &c1);
		626
		627	XRenderComposite (cc.dpy, PictOpOver, white, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
		628
		629	XRenderFreePicture (cc.dpy, white);
		630
		631	// STEP 2: convolve the image with a 3x1 filter
		632	// a 2x1 filter would obviously suffice, but given the total lack of specification
		633	// for xrender, I expect different xrender implementations to randomly diverge.
		634	// we also halve the image, and hope for the best (again, for lack of specs).
		635	composer cc2 (cc.dstimg);
		636
		637	XFixed kernel [] = {
		638	XDoubleToFixed (3), XDoubleToFixed (1),
		639	XDoubleToFixed (0), XDoubleToFixed (mul), XDoubleToFixed (add)
		640	};
		641
		642	XTransform h_halve = {
		643	131072, 0, 0,
		644	0, 65536, 0,
		645	0, 0, 65536
		646	};
		647
		648	XRenderSetPictureFilter (cc.dpy, cc2.src, "nearest", 0, 0);
		649	XRenderSetPictureTransform (cc.dpy, cc2.src, &h_halve);
		650	XRenderSetPictureFilter (cc.dpy, cc2.src, FilterConvolution, kernel, ecb_array_length (kernel));
		651
		652	XRenderComposite (cc.dpy, PictOpSrc, cc2.src, None, cc2.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
		653
		654	return cc2;
		655	}
		656
		657	ecb_noinline static void
		658	extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
		659	{
		660	int32_t x = clamp (c, cl0, cl1);
		661	c -= x;
		662	xc = x;
		663	}
		664
		665	ecb_noinline static bool
		666	extract (int32_t cl0, int32_t cl1, int32_t &r, int32_t &g, int32_t &b, int32_t &a, unsigned short &xr, unsigned short &xg, unsigned short &xb, unsigned short &xa)
		667	{
		668	extract (cl0, cl1, r, xr);
		669	extract (cl0, cl1, g, xg);
		670	extract (cl0, cl1, b, xb);
		671	extract (cl0, cl1, a, xa);
		672
		673	return xr \| xg \| xb \| xa;
150	}	674	}
151		675
152	void	676	void
153	rxvt_img::brightness (double r, double g, double b, double a)	677	rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
154	{	678	{
		679	unshare ();
		680
155	Display *dpy = s->display->dpy;	681	Display *dpy = s->dpy;
156	Picture src = create_xrender_mask (dpy, pm, True);
157	Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);	682	Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
158		683
		684	// loop should not be needed for brightness, as only -1..1 makes sense
		685	//while (r \| g \| b \| a)
		686	{
		687	unsigned short xr, xg, xb, xa;
159	XRenderColor mask_c;	688	XRenderColor mask_c;
160	mask_c.red = float_to_component (r);	689
161	mask_c.green = float_to_component (g);	690	if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
162	mask_c.blue = float_to_component (b);
163	mask_c.alpha = float_to_component (a);
164	XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1);	691	XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
165		692
166	XRenderComposite (dpy, PictOpAdd, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);	693	if (extract (-65535, 0, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
		694	{
		695	XRenderColor mask_w = { 65535, 65535, 65535, 65535 };
		696	XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
		697	mask_c.red = -mask_c.red; //TODO: verify that doing clamp, assign, and negation does the right thing
		698	mask_c.green = -mask_c.green;
		699	mask_c.blue = -mask_c.blue;
		700	mask_c.alpha = -mask_c.alpha;
		701	XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
		702	XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
		703	}
		704	}
		705
		706	XRenderFreePicture (dpy, dst);
167	}	707	}
168		708
169	void	709	void
170	rxvt_img::contrast (double r, double g, double b, double a)	710	rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
171	{	711	{
172	if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL))	712	if (r < 0 \|\| g < 0 \|\| b < 0 \|\| a < 0)
173	return;	713	rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
174		714
175	Display *dpy = s->display->dpy;	715	// premultiply (yeah, these are not exact, sue me or fix it)
176	Picture src = create_xrender_mask (dpy, pm, True);	716	r = (r * (a >> 8)) >> 8;
177	Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);	717	g = (g * (a >> 8)) >> 8;
		718	b = (b * (a >> 8)) >> 8;
178		719
		720	composer cc (this);
		721	rxvt_img *img = cc;
		722	img->fill (rgba (0, 0, 0, 0));
		723
		724	cc.mask (true);
		725
		726	//TODO: this operator does not yet implement some useful contrast
		727	while (r \| g \| b \| a)
		728	{
		729	unsigned short xr, xg, xb, xa;
179	XRenderColor mask_c;	730	XRenderColor mask_c;
180	mask_c.red = float_to_component (r);	731
181	mask_c.green = float_to_component (g);	732	if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
182	mask_c.blue = float_to_component (b);	733	{
183	mask_c.alpha = float_to_component (a);
184	XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1);	734	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &mask_c, 0, 0, 1, 1);
185
186	XRenderComposite (dpy, PictOpMultiply, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);	735	XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
		736	}
		737	}
		738
		739	::swap (img->ref, ref);
		740	::swap (img->pm , pm );
		741
		742	delete img;
187	}	743	}
188		744
189	void	745	void
190	rxvt_img::render (GdkPixbuf *pixbuf, int src_x, int src_y, int width, int height, int dst_x, int dst_y)	746	rxvt_img::draw (rxvt_img *img, int op, nv mask)
191	{	747	{
192	//TODO	748	unshare ();
193	}
194		749
		750	composer cc (img, this);
		751
		752	if (mask != 1.)
		753	cc.mask (rgba (0, 0, 0, float_to_component (mask)));
		754
		755	XRenderComposite (cc.dpy, op, cc.src, cc.msk, cc.dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h);
		756	}
		757
195	rxvt_img *	758	rxvt_img *
196	rxvt_img::copy ()	759	rxvt_img::clone ()
197	{	760	{
198	GC gc = XCreateGC (s->display->dpy, pm, 0, 0);	761	return new rxvt_img (*this);
199	Pixmap pm2 = XCreatePixmap (s->display->dpy, pm, w, h, format->depth);
200	XCopyArea (s->display->dpy, pm, pm2, gc, 0, 0, w, h, 0, 0);
201	XFreeGC (s->display->dpy, gc);
202	return new rxvt_img (s, format, w, h, pm2);
203	}	762	}
204		763
205	rxvt_img *	764	rxvt_img *
206	rxvt_img::transform (int new_width, int new_height, double matrix[16])	765	rxvt_img::reify ()
207	{	766	{
208	//TODO	767	if (x == 0 && y == 0 && w == ref->w && h == ref->h)
		768	return clone ();
		769
		770	// add an alpha channel if...
		771	bool alpha = !format->direct.alphaMask // pixmap has none yet
		772	&& (x \|\| y) // we need one because of non-zero offset
		773	&& repeat == RepeatNone; // and we have no good pixels to fill with
		774
		775	composer cc (this, new rxvt_img (s, alpha ? find_alpha_format_for (s->dpy, format) : format,
		776	0, 0, w, h, repeat));
		777
		778	if (repeat == RepeatNone)
		779	{
		780	XRenderColor rc = { 0, 0, 0, 0 };
		781	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
		782	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
		783	}
		784	else
		785	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
		786
		787	return cc;
		788	}
		789
		790	rxvt_img *
		791	rxvt_img::sub_rect (int x, int y, int width, int height)
		792	{
		793	rxvt_img *img = clone ();
		794
		795	img->x -= x;
		796	img->y -= y;
		797
		798	if (w != width \|\| h != height)
		799	{
		800	img->w = width;
		801	img->h = height;
		802
		803	rxvt_img *img2 = img->reify ();
		804	delete img;
		805	img = img2;
		806	}
		807
		808	return img;
		809	}
		810
		811	rxvt_img *
		812	rxvt_img::transform (const nv matrix[3][3])
		813	{
		814	return transform (mat3x3 (&matrix[0][0]));
		815	}
		816
		817	rxvt_img *
		818	rxvt_img::transform (const nv *matrix)
		819	{
		820	mat3x3 m (matrix);
		821
		822	// calculate new pixel bounding box coordinates
		823	nv rmin[2], rmax[2];
		824
		825	for (int i = 0; i < 2; ++i)
		826	{
		827	nv v;
		828
		829	v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v;
		830	v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v);
		831	v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
		832	v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
		833	}
		834
		835	float sx = rmin [0] - x;
		836	float sy = rmin [1] - y;
		837
		838	// TODO: adjust matrix for subpixel accuracy
		839	int nx = floor (rmin [0]);
		840	int ny = floor (rmin [1]);
		841
		842	int new_width = ceil (rmax [0] - rmin [0]);
		843	int new_height = ceil (rmax [1] - rmin [1]);
		844
		845	mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
		846
		847	composer cc (this, new rxvt_img (s, format, nx, ny, new_width, new_height, repeat));
		848
		849	XTransform xfrm;
		850
		851	for (int i = 0; i < 3; ++i)
		852	for (int j = 0; j < 3; ++j)
		853	xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
		854
		855	XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
		856	XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
		857	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
		858
		859	return cc;
209	}	860	}
210		861
211	rxvt_img *	862	rxvt_img *
212	rxvt_img::scale (int new_width, int new_height)	863	rxvt_img::scale (int new_width, int new_height)
213	{	864	{
214	// use transform	865	if (w == new_width && h == new_height)
215	//TODO	866	return clone ();
216	}
217		867
218	rxvt_img *	868	int old_repeat_mode = repeat;
219	rxvt_img::convert_to (XRenderPictFormat *new_format)	869	repeat = RepeatPad; // not right, but xrender can't properly scale it seems
220	{
221	Display *dpy = s->display->dpy;
222	Pixmap new_pm = XCreatePixmap (dpy, pm, w, h, new_format->depth);
223	Picture src = XRenderCreatePicture (dpy, pm, format, 0, 0);
224	Picture dst = XRenderCreatePicture (dpy, new_pm, new_format, 0, 0);
225		870
226	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);	871	rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
227		872
228	XRenderFreePicture (dpy, src);	873	repeat = old_repeat_mode;
229	XRenderFreePicture (dpy, dst);	874	img->repeat = repeat;
230
231	rxvt_img *img = new rxvt_img (
232	s,
233	new_format,
234	w,
235	h,
236	new_pm
237	);
238		875
239	return img;	876	return img;
240	}	877	}
241		878
		879	rxvt_img *
		880	rxvt_img::rotate (int cx, int cy, nv phi)
		881	{
		882	move (-cx, -cy);
		883	rxvt_img *img = transform (mat3x3::rotate (phi));
		884	move ( cx, cy);
		885	img->move (cx, cy);
		886
		887	return img;
		888	}
		889
		890	rxvt_img *
		891	rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
		892	{
		893	if (new_format == format)
		894	return clone ();
		895
		896	composer cc (this, new rxvt_img (s, new_format, x, y, w, h, repeat));
		897
		898	int op = PictOpSrc;
		899
		900	if (format->direct.alphaMask && !new_format->direct.alphaMask)
		901	{
		902	// does it have to be that complicated
		903	XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
		904	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
		905
		906	op = PictOpOver;
		907	}
		908
		909	XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
		910
		911	return cc;
		912	}
		913
		914	rxvt_img *
		915	rxvt_img::tint (const rgba &c)
		916	{
		917	composer cc (this);
		918	cc.mask (true);
		919	cc.fill (c);
		920
		921	XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
		922
		923	return cc;
		924	}
		925
		926	rxvt_img *
		927	rxvt_img::filter (const char name, int nparams, nv params)
		928	{
		929	composer cc (this);
		930
		931	XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
		932
		933	for (int i = 0; i < nparams; ++i)
		934	xparams [i] = XDoubleToFixed (params [i]);
		935
		936	XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
		937
		938	XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
		939
		940	return cc;
		941	}
		942
242	#endif	943	#endif
243		944

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing rxvt-unicode/src/rxvtimg.C (file contents): Revision 1.7 by sf-exg, Sun Jun 3 20:34:25 2012 UTC vs. Revision 1.102 by root, Sat Jul 7 07:00:17 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/rxvtimg.C (file contents):
Revision 1.7 by sf-exg, Sun Jun 3 20:34:25 2012 UTC vs.
Revision 1.102 by root, Sat Jul 7 07:00:17 2012 UTC