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

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

Diff Legend

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

Comparing rxvt-unicode/src/rxvtimg.C (file contents): Revision 1.18 by sf-exg, Tue Jun 5 12:30:37 2012 UTC vs. Revision 1.112 by root, Tue Sep 17 18:31:32 2019 UTC

Diff Legend

Comparing rxvt-unicode/src/rxvtimg.C (file contents):
Revision 1.18 by sf-exg, Tue Jun 5 12:30:37 2012 UTC vs.
Revision 1.112 by root, Tue Sep 17 18:31:32 2019 UTC