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

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

Diff Legend

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

Comparing rxvt-unicode/src/rxvtimg.C (file contents): Revision 1.17 by root, Mon Jun 4 18:17:25 2012 UTC vs. Revision 1.105 by sf-exg, Sat Jan 19 10:04:34 2013 UTC

Diff Legend

Comparing rxvt-unicode/src/rxvtimg.C (file contents):
Revision 1.17 by root, Mon Jun 4 18:17:25 2012 UTC vs.
Revision 1.105 by sf-exg, Sat Jan 19 10:04:34 2013 UTC