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

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

Diff Legend

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

Comparing rxvt-unicode/src/rxvtimg.C (file contents): Revision 1.21 by sf-exg, Tue Jun 5 14:59:44 2012 UTC vs. Revision 1.107 by root, Thu May 22 18:54:33 2014 UTC

Diff Legend

Comparing rxvt-unicode/src/rxvtimg.C (file contents):
Revision 1.21 by sf-exg, Tue Jun 5 14:59:44 2012 UTC vs.
Revision 1.107 by root, Thu May 22 18:54:33 2014 UTC