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

Comparing rxvt-unicode/src/rxvtimg.C (file contents):
Revision 1.14 by root, Mon Jun 4 15:53:12 2012 UTC vs.
Revision 1.99 by root, Mon Jul 2 01:32:26 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)
		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, 0, 0, w, h);
		488	XRenderFreePicture (dpy, src);
		489	}
		490
		491	void
		492	rxvt_img::add_alpha ()
		493	{
		494	if (format->direct.alphaMask)
		495	return;
		496
		497	composer cc (this, new rxvt_img (s, find_alpha_format_for (s->dpy, format), x, y, w, h, repeat));
		498
		499	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
		500
53	rxvt_img *img = clone ();	501	rxvt_img *img = cc;
54		502
55	::swap (pm , img->pm);	503	::swap (img->ref, ref);
56	::swap (shared, img->shared);	504	::swap (img->pm , pm );
57		505
58	delete img;	506	delete img;
59	}	507	}
60		508
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	509	static void
72	get_gaussian_kernel (int radius, int width, double kernel, XFixed params)	510	get_gaussian_kernel (int radius, int width, nv kernel, XFixed params)
73	{	511	{
74	double sigma = radius / 2.0;	512	nv sigma = radius / 2.0;
75	double scale = sqrt (2.0 * M_PI) * sigma;	513	nv scale = sqrt (2.0 * M_PI) * sigma;
76	double sum = 0.0;	514	nv sum = 0.0;
77		515
78	for (int i = 0; i < width; i++)	516	for (int i = 0; i < width; i++)
79	{	517	{
80	double x = i - width / 2;	518	nv x = i - width / 2;
81	kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;	519	kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;
82	sum += kernel[i];	520	sum += kernel[i];
83	}	521	}
84		522
85	params[0] = XDoubleToFixed (width);	523	params[0] = XDoubleToFixed (width);
…		…
87		525
88	for (int i = 0; i < width; i++)	526	for (int i = 0; i < width; i++)
89	params[i+2] = XDoubleToFixed (kernel[i] / sum);	527	params[i+2] = XDoubleToFixed (kernel[i] / sum);
90	}	528	}
91		529
92	void	530	rxvt_img *
93	rxvt_img::blur (int rh, int rv)	531	rxvt_img::blur (int rh, int rv)
94	{	532	{
95	if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))	533	if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))
96	return;	534	return clone ();
97		535
98	Display *dpy = s->display->dpy;	536	Display *dpy = s->dpy;
99	int size = max (rh, rv) * 2 + 1;	537	int size = max (rh, rv) * 2 + 1;
100	double kernel = (double )malloc (size * sizeof (double));	538	nv kernel = (nv )malloc (size * sizeof (nv));
101	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	539	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
		540	rxvt_img *img = new_empty ();
102		541
103	XRenderPictureAttributes pa;	542	XRenderPictureAttributes pa;
104
105	pa.repeat = RepeatPad;	543	pa.repeat = RepeatPad;
106	Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);	544	Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
		545	Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
		546
107	Pixmap tmp = XCreatePixmap (dpy, pm, w, h, format->depth);	547	Pixmap tmp_pm = XCreatePixmap (dpy, pm, w, h, format->depth);
108	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);	548	Picture tmp = XRenderCreatePicture (dpy, tmp_pm , format, CPRepeat, &pa);
109	XFreePixmap (dpy, tmp);	549	XFreePixmap (dpy, tmp_pm);
110		550
111	if (kernel && params)	551	if (kernel && params)
112	{	552	{
113	size = rh * 2 + 1;	553	size = rh * 2 + 1;
114	get_gaussian_kernel (rh, size, kernel, params);	554	get_gaussian_kernel (rh, size, kernel, params);
115		555
116	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	556	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
117	XRenderComposite (dpy,	557	XRenderComposite (dpy,
118	PictOpSrc,	558	PictOpSrc,
119	src,	559	src,
		560	None,
		561	tmp,
		562	0, 0,
		563	0, 0,
		564	0, 0,
		565	w, h);
		566
		567	size = rv * 2 + 1;
		568	get_gaussian_kernel (rv, size, kernel, params);
		569	::swap (params[0], params[1]);
		570
		571	XRenderSetPictureFilter (dpy, tmp, FilterConvolution, params, size+2);
		572	XRenderComposite (dpy,
		573	PictOpSrc,
		574	tmp,
120	None,	575	None,
121	dst,	576	dst,
122	0, 0,	577	0, 0,
123	0, 0,	578	0, 0,
124	0, 0,	579	0, 0,
125	w, h);	580	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	}	581	}
144		582
145	free (kernel);	583	free (kernel);
146	free (params);	584	free (params);
		585
147	XRenderFreePicture (dpy, src);	586	XRenderFreePicture (dpy, src);
148	XRenderFreePicture (dpy, dst);	587	XRenderFreePicture (dpy, dst);
149	}	588	XRenderFreePicture (dpy, tmp);
150		589
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;	590	return img;
		591	}
		592
		593	ecb_noinline static void
		594	extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
		595	{
		596	int32_t x = clamp (c, cl0, cl1);
		597	c -= x;
		598	xc = x;
		599	}
		600
		601	ecb_noinline static bool
		602	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)
		603	{
		604	extract (cl0, cl1, r, xr);
		605	extract (cl0, cl1, g, xg);
		606	extract (cl0, cl1, b, xb);
		607	extract (cl0, cl1, a, xa);
		608
		609	return xr \| xg \| xb \| xa;
164	}	610	}
165		611
166	void	612	void
167	rxvt_img::brightness (double r, double g, double b, double a)	613	rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
168	{	614	{
		615	unshare ();
		616
169	Display *dpy = s->display->dpy;	617	Display *dpy = s->dpy;
170	Picture src = create_xrender_mask (dpy, pm, True);
171	Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);	618	Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
172		619
		620	// loop should not be needed for brightness, as only -1..1 makes sense
		621	//while (r \| g \| b \| a)
		622	{
		623	unsigned short xr, xg, xb, xa;
173	XRenderColor mask_c;	624	XRenderColor mask_c;
174	mask_c.red = float_to_component (r);	625
175	mask_c.green = float_to_component (g);	626	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);	627	XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
179		628
180	XRenderComposite (dpy, PictOpAdd, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);	629	if (extract (-65535, 0, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
		630	{
		631	XRenderColor mask_w = { 65535, 65535, 65535, 65535 };
		632	XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
		633	mask_c.red = -mask_c.red; //TODO: verify that doing clamp, assign, and negation does the right thing
		634	mask_c.green = -mask_c.green;
		635	mask_c.blue = -mask_c.blue;
		636	mask_c.alpha = -mask_c.alpha;
		637	XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
		638	XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
		639	}
		640	}
		641
		642	XRenderFreePicture (dpy, dst);
181	}	643	}
182		644
183	void	645	void
184	rxvt_img::contrast (double r, double g, double b, double a)	646	rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
185	{	647	{
186	if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL))	648	if (r < 0 \|\| g < 0 \|\| b < 0 \|\| a < 0)
187	return;	649	rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
188		650
189	Display *dpy = s->display->dpy;	651	// premultiply (yeah, these are not exact, sue me or fix it)
190	Picture src = create_xrender_mask (dpy, pm, True);	652	r = (r * (a >> 8)) >> 8;
191	Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);	653	g = (g * (a >> 8)) >> 8;
		654	b = (b * (a >> 8)) >> 8;
192		655
		656	composer cc (this);
		657	rxvt_img *img = cc;
		658	img->fill (rgba (0, 0, 0, 0));
		659
		660	cc.mask (true);
		661
		662	//TODO: this operator does not yet implement some useful contrast
		663	while (r \| g \| b \| a)
		664	{
		665	unsigned short xr, xg, xb, xa;
193	XRenderColor mask_c;	666	XRenderColor mask_c;
194	mask_c.red = float_to_component (r);	667
195	mask_c.green = float_to_component (g);	668	if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
196	mask_c.blue = float_to_component (b);	669	{
197	mask_c.alpha = float_to_component (a);
198	XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1);	670	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &mask_c, 0, 0, 1, 1);
199
200	XRenderComposite (dpy, PictOpMultiply, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);	671	XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
201	}	672	}
		673	}
202		674
203	bool	675	::swap (img->ref, ref);
204	rxvt_img::render_pixbuf (GdkPixbuf *pixbuf, int src_x, int src_y, int width, int height, int dst_x, int dst_y)	676	::swap (img->pm , pm );
205	{
206	bool argb = format->id == PictStandardARGB32;
207		677
		678	delete img;
		679	}
		680
		681	void
		682	rxvt_img::draw (rxvt_img *img, int op, nv mask)
		683	{
		684	unshare ();
		685
		686	composer cc (img, this);
		687
		688	if (mask != 1.)
		689	cc.mask (rgba (0, 0, 0, float_to_component (mask)));
		690
		691	XRenderComposite (cc.dpy, op, cc.src, cc.msk, cc.dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h);
		692	}
		693
		694	rxvt_img *
		695	rxvt_img::clone ()
		696	{
		697	return new rxvt_img (*this);
		698	}
		699
		700	rxvt_img *
		701	rxvt_img::reify ()
		702	{
		703	if (x == 0 && y == 0 && w == ref->w && h == ref->h)
		704	return clone ();
		705
208	Display *dpy = s->display->dpy;	706	Display *dpy = s->dpy;
209		707
210	if (s->visual->c_class != TrueColor)	708	// add an alpha channel if...
211	return false;	709	bool alpha = !format->direct.alphaMask // pixmap has none yet
		710	&& (x \|\| y) // we need one because of non-zero offset
		711	&& repeat == RepeatNone; // and we have no good pixels to fill with
212		712
213	uint32_t red_mask, green_mask, blue_mask, alpha_mask;	713	composer cc (this, new rxvt_img (s, alpha ? find_alpha_format_for (s->dpy, format) : format,
		714	0, 0, w, h, repeat));
214		715
215	if (argb)	716	if (alpha)
216	{	717	{
217	red_mask = 0xff << 16;	718	XRenderColor rc = { 0, 0, 0, 0 };
218	green_mask = 0xff << 8;	719	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
219	blue_mask = 0xff;	720	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
220	alpha_mask = 0xff << 24;
221	}	721	}
222	else	722	else
223	{	723	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
224	red_mask = s->visual->red_mask;	724
225	green_mask = s->visual->green_mask;	725	return cc;
226	blue_mask = s->visual->blue_mask;	726	}
227	alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;	727
		728	rxvt_img *
		729	rxvt_img::sub_rect (int x, int y, int width, int height)
		730	{
		731	rxvt_img *img = clone ();
		732
		733	img->x -= x;
		734	img->y -= y;
		735
		736	if (w != width \|\| h != height)
228	}	737	{
		738	img->w = width;
		739	img->h = height;
229		740
230	int width_r = ecb_popcount32 (red_mask);	741	rxvt_img *img2 = img->reify ();
231	int width_g = ecb_popcount32 (green_mask);	742	delete img;
232	int width_b = ecb_popcount32 (blue_mask);	743	img = img2;
233	int width_a = ecb_popcount32 (alpha_mask);
234
235	if (width_r > 8 \|\| width_g > 8 \|\| width_b > 8 \|\| width_a > 8)
236	return false;
237
238	int sh_r = ecb_ctz32 (red_mask);
239	int sh_g = ecb_ctz32 (green_mask);
240	int sh_b = ecb_ctz32 (blue_mask);
241	int sh_a = ecb_ctz32 (alpha_mask);
242
243	if (width > 32767 \|\| height > 32767)
244	return false;
245
246	XImage *ximage = XCreateImage (dpy, s->visual, argb ? 32 : format->depth, ZPixmap, 0, 0,
247	width, height, 32, 0);
248	if (!ximage)
249	return false;
250
251	if (height > INT_MAX / ximage->bytes_per_line
252	\|\| !(ximage->data = (char )malloc (height ximage->bytes_per_line)))
253	{	744	}
254	XDestroyImage (ximage);	745
255	return false;	746	return img;
		747	}
		748
		749	rxvt_img *
		750	rxvt_img::transform (const nv matrix[3][3])
		751	{
		752	return transform (mat3x3 (&matrix[0][0]));
		753	}
		754
		755	rxvt_img *
		756	rxvt_img::transform (const nv *matrix)
		757	{
		758	mat3x3 m (matrix);
		759
		760	// calculate new pixel bounding box coordinates
		761	nv rmin[2], rmax[2];
		762
		763	for (int i = 0; i < 2; ++i)
256	}	764	{
		765	nv v;
257		766
258	GC gc = XCreateGC (dpy, pm, 0, 0);	767	v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v;
259		768	v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v);
260	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;	769	v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
261		770	v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
262	int rowstride = gdk_pixbuf_get_rowstride (pixbuf);
263	int channels = gdk_pixbuf_get_n_channels (pixbuf);
264	unsigned char row = gdk_pixbuf_get_pixels (pixbuf) + src_y rowstride + src_x * channels;
265	char *line = ximage->data;
266
267	rgba c (0, 0, 0);
268
269	if (channels == 4 && alpha_mask == 0)
270	{	771	}
271	//pix_colors[Color_bg].get (c);
272	//TODO
273	c.r >>= 8;
274	c.g >>= 8;
275	c.b >>= 8;
276	}
277		772
278	for (int y = 0; y < height; y++)	773	float sx = rmin [0] - x;
279	{	774	float sy = rmin [1] - y;
280	for (int x = 0; x < width; x++)
281	{
282	unsigned char pixel = row + x channels;
283	uint32_t value;
284	unsigned char r, g, b, a;
285		775
286	if (channels == 4)	776	// TODO: adjust matrix for subpixel accuracy
287	{	777	int nx = floor (rmin [0]);
288	a = pixel[3];	778	int ny = floor (rmin [1]);
289	r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
290	g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
291	b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
292	}
293	else
294	{
295	a = 0xff;
296	r = pixel[0];
297	g = pixel[1];
298	b = pixel[2];
299	}
300		779
301	value = ((r >> (8 - width_r)) << sh_r)	780	int new_width = ceil (rmax [0] - rmin [0]);
302	\| ((g >> (8 - width_g)) << sh_g)	781	int new_height = ceil (rmax [1] - rmin [1]);
303	\| ((b >> (8 - width_b)) << sh_b)
304	\| ((a >> (8 - width_a)) << sh_a);
305		782
306	if (ximage->bits_per_pixel == 32)	783	mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
307	((uint32_t *)line)[x] = value;
308	else
309	XPutPixel (ximage, x, y, value);
310	}
311		784
312	row += rowstride;	785	composer cc (this, new rxvt_img (s, format, nx, ny, new_width, new_height, repeat));
313	line += ximage->bytes_per_line;
314	}
315
316	XPutImage (dpy, pm, gc, ximage, 0, 0, dst_x, dst_y, width, height);
317	XDestroyImage (ximage);
318	XFreeGC (dpy, gc);
319
320	return true;
321	}
322
323	rxvt_img *
324	rxvt_img::clone ()
325	{
326	GC gc = XCreateGC (s->display->dpy, pm, 0, 0);
327	Pixmap pm2 = XCreatePixmap (s->display->dpy, pm, w, h, format->depth);
328	XCopyArea (s->display->dpy, pm, pm2, gc, 0, 0, w, h, 0, 0);
329	XFreeGC (s->display->dpy, gc);
330	return new rxvt_img (s, format, w, h, pm2);
331	}
332
333	rxvt_img *
334	rxvt_img::transform (int new_width, int new_height, int repeat, double matrix[9])
335	{
336	rxvt_img *img = new rxvt_img (s, format, new_width, new_height);
337
338	Display *dpy = s->display->dpy;
339	XRenderPictureAttributes pa;
340	pa.repeat = repeat;
341	Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
342	Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
343		786
344	XTransform xfrm;	787	XTransform xfrm;
345		788
346	for (int i = 0; i < 3; ++i)	789	for (int i = 0; i < 3; ++i)
347	for (int j = 0; j < 3; ++j)	790	for (int j = 0; j < 3; ++j)
348	xfrm.matrix [i][j] = XDoubleToFixed (matrix [i * 3 + j]);	791	xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
349		792
		793	XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
350	XRenderSetPictureTransform (dpy, src, &xfrm);	794	XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
351	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, new_width, new_height);	795	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
352		796
353	XRenderFreePicture (dpy, src);	797	return cc;
354	XRenderFreePicture (dpy, dst);	798	}
		799
		800	rxvt_img *
		801	rxvt_img::scale (int new_width, int new_height)
		802	{
		803	if (w == new_width && h == new_height)
		804	return clone ();
		805
		806	int old_repeat_mode = repeat;
		807	repeat = RepeatPad; // not right, but xrender can't properly scale it seems
		808
		809	rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
		810
		811	repeat = old_repeat_mode;
		812	img->repeat = repeat;
355		813
356	return img;	814	return img;
357	}	815	}
358		816
359	rxvt_img *	817	rxvt_img *
360	rxvt_img::scale (int new_width, int new_height)	818	rxvt_img::rotate (int cx, int cy, nv phi)
361	{	819	{
362	double matrix[9] = {	820	move (-cx, -cy);
363	new_width / (double)w, 0, 0,	821	rxvt_img *img = transform (mat3x3::rotate (phi));
364	0, new_height / (double)h, 0,	822	move ( cx, cy);
365	0, 0, 1	823	img->move (cx, cy);
366	};
367
368	return transform (new_width, new_height, RepeatNormal, matrix);
369	}
370
371	rxvt_img *
372	rxvt_img::convert_to (XRenderPictFormat *new_format)
373	{
374	rxvt_img *img = new rxvt_img (s, new_format, w, h);
375
376	Display *dpy = s->display->dpy;
377	Picture src = XRenderCreatePicture (dpy, pm, format, 0, 0);
378	Picture dst = XRenderCreatePicture (dpy, img->pm, new_format, 0, 0);
379
380	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);
381
382	XRenderFreePicture (dpy, src);
383	XRenderFreePicture (dpy, dst);
384		824
385	return img;	825	return img;
386	}	826	}
387		827
		828	rxvt_img *
		829	rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
		830	{
		831	if (new_format == format)
		832	return clone ();
		833
		834	composer cc (this, new rxvt_img (s, new_format, x, y, w, h, repeat));
		835
		836	int op = PictOpSrc;
		837
		838	if (format->direct.alphaMask && !new_format->direct.alphaMask)
		839	{
		840	// does it have to be that complicated
		841	XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
		842	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
		843
		844	op = PictOpOver;
		845	}
		846
		847	XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
		848
		849	return cc;
		850	}
		851
		852	rxvt_img *
		853	rxvt_img::tint (const rgba &c)
		854	{
		855	composer cc (this);
		856	cc.mask (true);
		857	cc.fill (c);
		858
		859	XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
		860
		861	return cc;
		862	}
		863
		864	rxvt_img *
		865	rxvt_img::filter (const char name, int nparams, nv params)
		866	{
		867	composer cc (this);
		868
		869	XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
		870
		871	for (int i = 0; i < nparams; ++i)
		872	xparams [i] = XDoubleToFixed (params [i]);
		873
		874	XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
		875
		876	XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
		877
		878	return cc;
		879	}
		880
388	#endif	881	#endif
389		882

Diff Legend

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

Comparing rxvt-unicode/src/rxvtimg.C (file contents): Revision 1.14 by root, Mon Jun 4 15:53:12 2012 UTC vs. Revision 1.99 by root, Mon Jul 2 01:32:26 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/rxvtimg.C (file contents):
Revision 1.14 by root, Mon Jun 4 15:53:12 2012 UTC vs.
Revision 1.99 by root, Mon Jul 2 01:32:26 2012 UTC