[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.100 by root, Mon Jul 2 02:01:41 2012 UTC

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

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.100 by root, Mon Jul 2 02:01:41 2012 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.100 by root, Mon Jul 2 02:01:41 2012 UTC