[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.113 by sf-exg, Sat May 8 06:15:32 2021 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	{
173	XRenderColor mask_c;	694	XRenderColor mask_c;
174	mask_c.red = float_to_component (r);	695
175	mask_c.green = float_to_component (g);	696	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);	697	XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
179		698
180	XRenderComposite (dpy, PictOpAdd, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);	699	if (extract (-65535, 0, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
		700	{
		701	XRenderColor mask_w = { 65535, 65535, 65535, 65535 };
		702	XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
		703	mask_c.red = -mask_c.red; //TODO: verify that doing clamp, assign, and negation does the right thing
		704	mask_c.green = -mask_c.green;
		705	mask_c.blue = -mask_c.blue;
		706	mask_c.alpha = -mask_c.alpha;
		707	XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
		708	XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
		709	}
		710	}
		711
		712	XRenderFreePicture (dpy, dst);
181	}	713	}
182		714
183	void	715	void
184	rxvt_img::contrast (double r, double g, double b, double a)	716	rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
185	{	717	{
186	if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL))	718	if (r < 0 \|\| g < 0 \|\| b < 0 \|\| a < 0)
187	return;	719	rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
188		720
189	Display *dpy = s->display->dpy;	721	// premultiply (yeah, these are not exact, sue me or fix it)
190	Picture src = create_xrender_mask (dpy, pm, True);	722	r = (r * (a >> 8)) >> 8;
191	Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);	723	g = (g * (a >> 8)) >> 8;
		724	b = (b * (a >> 8)) >> 8;
192		725
		726	composer cc (this);
		727	rxvt_img *img = cc;
		728	img->fill (rgba (0, 0, 0, 0));
		729
		730	cc.mask (true);
		731
		732	//TODO: this operator does not yet implement some useful contrast
		733	while (r \| g \| b \| a)
		734	{
193	XRenderColor mask_c;	735	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		736
200	XRenderComposite (dpy, PictOpMultiply, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);	737	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	{	738	{
271	unsigned char pixel = row + x channels;	739	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &mask_c, 0, 0, 1, 1);
272	uint32_t value;	740	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	}	741	}
300
301	row += rowstride;
302	line += ximage->bytes_per_line;
303	}	742	}
304		743
305	XPutImage (dpy, pm, gc, ximage, 0, 0, dst_x, dst_y, width, height);	744	::swap (img->ref, ref);
306	XDestroyImage (ximage);	745	::swap (img->pm , pm );
307	XFreeGC (dpy, gc);
308		746
309	return true;	747	delete img;
		748	}
		749
		750	void
		751	rxvt_img::draw (rxvt_img *img, int op, nv mask)
		752	{
		753	unshare ();
		754
		755	composer cc (img, this);
		756
		757	if (mask != 1.)
		758	cc.mask (rgba (0, 0, 0, float_to_component (mask)));
		759
		760	XRenderComposite (cc.dpy, op, cc.src, cc.msk, cc.dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h);
310	}	761	}
311		762
312	rxvt_img *	763	rxvt_img *
313	rxvt_img::clone ()	764	rxvt_img::clone ()
314	{	765	{
315	GC gc = XCreateGC (s->display->dpy, pm, 0, 0);	766	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	}	767	}
321		768
322	rxvt_img *	769	rxvt_img *
323	rxvt_img::transform (int new_width, int new_height, int repeat, double matrix[9])	770	rxvt_img::reify ()
324	{	771	{
325	rxvt_img *img = new rxvt_img (s, format, new_width, new_height);	772	if (x == 0 && y == 0 && w == ref->w && h == ref->h)
		773	return clone ();
326		774
327	Display *dpy = s->display->dpy;	775	// add an alpha channel if...
328	XRenderPictureAttributes pa;	776	bool alpha = !format->direct.alphaMask // pixmap has none yet
329	pa.repeat = repeat;	777	&& (x \|\| y) // we need one because of non-zero offset
330	Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);	778	&& repeat == RepeatNone; // and we have no good pixels to fill with
331	Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);	779
		780	composer cc (this, new rxvt_img (d, alpha ? find_alpha_format_for (d->dpy, format) : format,
		781	0, 0, w, h, repeat));
		782
		783	if (repeat == RepeatNone)
		784	{
		785	XRenderColor rc = { 0, 0, 0, 0 };
		786	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
		787	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
		788	}
		789	else
		790	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
		791
		792	return cc;
		793	}
		794
		795	rxvt_img *
		796	rxvt_img::sub_rect (int x, int y, int width, int height)
		797	{
		798	rxvt_img *img = clone ();
		799
		800	img->x -= x;
		801	img->y -= y;
		802
		803	if (w != width \|\| h != height)
		804	{
		805	img->w = width;
		806	img->h = height;
		807
		808	rxvt_img *img2 = img->reify ();
		809	delete img;
		810	img = img2;
		811	}
		812
		813	return img;
		814	}
		815
		816	rxvt_img *
		817	rxvt_img::transform (const nv matrix[3][3])
		818	{
		819	return transform (mat3x3 (&matrix[0][0]));
		820	}
		821
		822	rxvt_img *
		823	rxvt_img::transform (const nv *matrix)
		824	{
		825	mat3x3 m (matrix);
		826
		827	// calculate new pixel bounding box coordinates
		828	nv rmin[2], rmax[2];
		829
		830	for (int i = 0; i < 2; ++i)
		831	{
		832	nv v;
		833
		834	v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v;
		835	v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v);
		836	v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
		837	v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
		838	}
		839
		840	float sx = rmin [0] - x;
		841	float sy = rmin [1] - y;
		842
		843	// TODO: adjust matrix for subpixel accuracy
		844	int nx = floor (rmin [0]);
		845	int ny = floor (rmin [1]);
		846
		847	int new_width = ceil (rmax [0] - rmin [0]);
		848	int new_height = ceil (rmax [1] - rmin [1]);
		849
		850	mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
		851
		852	composer cc (this, new rxvt_img (d, format, nx, ny, new_width, new_height, repeat));
332		853
333	XTransform xfrm;	854	XTransform xfrm;
334		855
335	for (int i = 0; i < 3; ++i)	856	for (int i = 0; i < 3; ++i)
336	for (int j = 0; j < 3; ++j)	857	for (int j = 0; j < 3; ++j)
337	xfrm.matrix [i][j] = XDoubleToFixed (matrix [i * 3 + j]);	858	xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
338		859
339	XRenderSetPictureFilter (dpy, src, "good", 0, 0);	860	XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
340	XRenderSetPictureTransform (dpy, src, &xfrm);	861	XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
341	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, new_width, new_height);	862	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
342		863
343	XRenderFreePicture (dpy, src);	864	return cc;
344	XRenderFreePicture (dpy, dst);	865	}
		866
		867	rxvt_img *
		868	rxvt_img::scale (int new_width, int new_height)
		869	{
		870	if (w == new_width && h == new_height)
		871	return clone ();
		872
		873	int old_repeat_mode = repeat;
		874	repeat = RepeatPad; // not right, but xrender can't properly scale it seems
		875
		876	rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
		877
		878	repeat = old_repeat_mode;
		879	img->repeat = repeat;
345		880
346	return img;	881	return img;
347	}	882	}
348		883
349	rxvt_img *	884	rxvt_img *
350	rxvt_img::scale (int new_width, int new_height)	885	rxvt_img::rotate (int cx, int cy, nv phi)
351	{	886	{
352	double matrix[9] = {	887	move (-cx, -cy);
353	w / (double)new_width, 0, 0,	888	rxvt_img *img = transform (mat3x3::rotate (phi));
354	0, h / (double)new_height, 0,	889	move ( cx, cy);
355	0, 0, 1	890	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		891
390	return img;	892	return img;
391	}	893	}
392		894
		895	rxvt_img *
		896	rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
		897	{
		898	if (new_format == format)
		899	return clone ();
		900
		901	composer cc (this, new rxvt_img (d, new_format, x, y, w, h, repeat));
		902
		903	int op = PictOpSrc;
		904
		905	if (format->direct.alphaMask && !new_format->direct.alphaMask)
		906	{
		907	// does it have to be that complicated
		908	XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
		909	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
		910
		911	op = PictOpOver;
		912	}
		913
		914	XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
		915
		916	return cc;
		917	}
		918
		919	rxvt_img *
		920	rxvt_img::tint (const rgba &c)
		921	{
		922	composer cc (this);
		923	cc.mask (true);
		924	cc.fill (c);
		925
		926	XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
		927
		928	return cc;
		929	}
		930
		931	rxvt_img *
		932	rxvt_img::shade (nv factor, rgba c)
		933	{
		934	clamp_it (factor, -1., 1.);
		935	factor++;
		936
		937	if (factor > 1)
		938	{
		939	c.r = c.r * (2 - factor);
		940	c.g = c.g * (2 - factor);
		941	c.b = c.b * (2 - factor);
		942	}
		943	else
		944	{
		945	c.r = c.r * factor;
		946	c.g = c.g * factor;
		947	c.b = c.b * factor;
		948	}
		949
		950	rxvt_img *img = this->tint (c);
		951
		952	if (factor > 1)
		953	{
		954	c.a = 0xffff;
		955	c.r =
		956	c.g =
		957	c.b = 0xffff * (factor - 1);
		958
		959	img->brightness (c.r, c.g, c.b, c.a);
		960	}
		961
		962	return img;
		963	}
		964
		965	rxvt_img *
		966	rxvt_img::filter (const char name, int nparams, nv params)
		967	{
		968	composer cc (this);
		969
		970	XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
		971
		972	for (int i = 0; i < nparams; ++i)
		973	xparams [i] = XDoubleToFixed (params [i]);
		974
		975	XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
		976
		977	XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
		978
		979	return cc;
		980	}
		981
393	#endif	982	#endif
394		983

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.113 by sf-exg, Sat May 8 06:15:32 2021 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.113 by sf-exg, Sat May 8 06:15:32 2021 UTC