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

Comparing rxvt-unicode/src/rxvtimg.C (file contents):
Revision 1.21 by sf-exg, Tue Jun 5 14:59:44 2012 UTC vs.
Revision 1.98 by root, Sun Jun 17 21:58:18 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;
18	}	260	}
19		261
20	rxvt_img *	262	rxvt_img *
21	rxvt_img::new_from_root (rxvt_screen *s)	263	rxvt_img::new_from_root (rxvt_screen *s)
22	{	264	{
23	Display *dpy = s->display->dpy;	265	Display *dpy = s->dpy;
24	unsigned int root_pm_w, root_pm_h;	266	unsigned int root_pm_w, root_pm_h;
25	Pixmap root_pixmap = s->display->get_pixmap_property (s->display->xa[XA_XROOTPMAP_ID]);	267	Pixmap root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_XROOTPMAP_ID]);
26	if (root_pixmap == None)	268	if (root_pixmap == None)
27	root_pixmap = s->display->get_pixmap_property (s->display->xa[XA_ESETROOT_PMAP_ID]);	269	root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_ESETROOT_PMAP_ID]);
28		270
29	if (root_pixmap == None)	271	if (root_pixmap == None)
30	return 0;	272	return 0;
31		273
32	Window wdummy;	274	Window wdummy;
37	return 0;	279	return 0;
38		280
39	rxvt_img *img = new rxvt_img (	281	rxvt_img *img = new rxvt_img (
40	s,	282	s,
41	XRenderFindVisualFormat (dpy, DefaultVisual (dpy, s->display->screen)),	283	XRenderFindVisualFormat (dpy, DefaultVisual (dpy, s->display->screen)),
		284	0,
		285	0,
42	root_pm_w,	286	root_pm_w,
43	root_pm_h,	287	root_pm_h
44	root_pixmap
45	);	288	);
46		289
47	img->shared = true;	290	img->pm = root_pixmap;
		291	img->ref = new pixref (root_pm_w, root_pm_h);
		292	img->ref->ours = false;
		293
		294	return img;
		295	}
		296
		297	# if HAVE_PIXBUF
		298
		299	rxvt_img *
		300	rxvt_img::new_from_pixbuf (rxvt_screen s, GdkPixbuf pb)
		301	{
		302	Display *dpy = s->dpy;
		303
		304	int width = gdk_pixbuf_get_width (pb);
		305	int height = gdk_pixbuf_get_height (pb);
		306
		307	if (width > 32767 \|\| height > 32767) // well, we could upload in chunks
		308	rxvt_fatal ("rxvt_img::new_from_pixbuf: image too big (maximum size 32768x32768).\n");
		309
		310	// since we require rgb24/argb32 formats from xrender we assume
		311	// that both 24 and 32 bpp MUST be supported by any screen that supports xrender
		312
		313	int byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
		314
		315	XImage xi;
		316
		317	xi.width = width;
		318	xi.height = height;
		319	xi.xoffset = 0;
		320	xi.format = ZPixmap;
		321	xi.byte_order = ImageByteOrder (dpy);
		322	xi.bitmap_unit = 0; //XY only, unused
		323	xi.bitmap_bit_order = 0; //XY only, unused
		324	xi.bitmap_pad = BitmapPad (dpy);
		325	xi.depth = 32;
		326	xi.bytes_per_line = 0;
		327	xi.bits_per_pixel = 32; //Z only
		328	xi.red_mask = 0x00000000; //Z only, unused
		329	xi.green_mask = 0x00000000; //Z only, unused
		330	xi.blue_mask = 0x00000000; //Z only, unused
		331	xi.obdata = 0; // probably unused
		332
		333	bool byte_order_mismatch = byte_order != xi.byte_order;
		334
		335	if (!XInitImage (&xi))
		336	rxvt_fatal ("unable to initialise ximage, please report.\n");
		337
		338	if (height > INT_MAX / xi.bytes_per_line)
		339	rxvt_fatal ("rxvt_img::new_from_pixbuf: image too big for Xlib.\n");
		340
		341	xi.data = (char )rxvt_malloc (height xi.bytes_per_line);
		342
		343	int rowstride = gdk_pixbuf_get_rowstride (pb);
		344	bool pb_has_alpha = gdk_pixbuf_get_has_alpha (pb);
		345	unsigned char *row = gdk_pixbuf_get_pixels (pb);
		346
		347	char *line = xi.data;
		348
		349	for (int y = 0; y < height; y++)
		350	{
		351	unsigned char *src = row;
		352	uint32_t dst = (uint32_t )line;
		353
		354	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);
48		396
49	return img;	397	return img;
50	}	398	}
51		399
52	rxvt_img *	400	rxvt_img *
…		…
56	GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err);	404	GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err);
57		405
58	if (!pb)	406	if (!pb)
59	rxvt_fatal ("rxvt_img::new_from_file: %s\n", err->message);	407	rxvt_fatal ("rxvt_img::new_from_file: %s\n", err->message);
60		408
61	rxvt_img *img = new rxvt_img (	409	rxvt_img *img = new_from_pixbuf (s, pb);
62	s,
63	XRenderFindStandardFormat (s->display->dpy, gdk_pixbuf_get_has_alpha (pb) ? PictStandardARGB32 : PictStandardRGB24),
64	gdk_pixbuf_get_width (pb),
65	gdk_pixbuf_get_height (pb)
66	);
67		410
68	img->render_pixbuf (pb, 0, 0, img->w, img->h, 0, 0);	411	g_object_unref (pb);
69		412
70	return img;	413	return img;
71	}	414	}
72		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
73	rxvt_img::~rxvt_img ()	430	rxvt_img::~rxvt_img ()
74	{	431	{
75	if (!shared)	432	destroy ();
76	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;
77	}	461	}
78		462
79	void	463	void
80	rxvt_img::unshare ()	464	rxvt_img::unshare ()
81	{	465	{
82	if (!shared)	466	if (ref->cnt == 1 && ref->ours)
83	return;	467	return;
84		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
85	rxvt_img *img = clone ();	501	rxvt_img *img = cc;
86		502
87	::swap (pm , img->pm);	503	::swap (img->ref, ref);
88	::swap (shared, img->shared);	504	::swap (img->pm , pm );
89		505
90	delete img;	506	delete img;
91	}	507	}
92		508
93	void
94	rxvt_img::fill (const rxvt_color &c)
95	{
96	XGCValues gcv;
97	gcv.foreground = c;
98	GC gc = XCreateGC (s->display->dpy, pm, GCForeground, &gcv);
99	XFillRectangle (s->display->dpy, pm, gc, 0, 0, w, h);
100	XFreeGC (s->display->dpy, gc);
101	}
102
103	static void	509	static void
104	get_gaussian_kernel (int radius, int width, double kernel, XFixed params)	510	get_gaussian_kernel (int radius, int width, nv kernel, XFixed params)
105	{	511	{
106	double sigma = radius / 2.0;	512	nv sigma = radius / 2.0;
107	double scale = sqrt (2.0 * M_PI) * sigma;	513	nv scale = sqrt (2.0 * M_PI) * sigma;
108	double sum = 0.0;	514	nv sum = 0.0;
109		515
110	for (int i = 0; i < width; i++)	516	for (int i = 0; i < width; i++)
111	{	517	{
112	double x = i - width / 2;	518	nv x = i - width / 2;
113	kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;	519	kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;
114	sum += kernel[i];	520	sum += kernel[i];
115	}	521	}
116		522
117	params[0] = XDoubleToFixed (width);	523	params[0] = XDoubleToFixed (width);
…		…
119		525
120	for (int i = 0; i < width; i++)	526	for (int i = 0; i < width; i++)
121	params[i+2] = XDoubleToFixed (kernel[i] / sum);	527	params[i+2] = XDoubleToFixed (kernel[i] / sum);
122	}	528	}
123		529
124	void	530	rxvt_img *
125	rxvt_img::blur (int rh, int rv)	531	rxvt_img::blur (int rh, int rv)
126	{	532	{
127	if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))	533	if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))
128	return;	534	return clone ();
129		535
130	Display *dpy = s->display->dpy;	536	Display *dpy = s->dpy;
131	int size = max (rh, rv) * 2 + 1;	537	int size = max (rh, rv) * 2 + 1;
132	double kernel = (double )malloc (size * sizeof (double));	538	nv kernel = (nv )malloc (size * sizeof (nv));
133	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	539	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
		540	rxvt_img *img = new_empty ();
134		541
135	XRenderPictureAttributes pa;	542	XRenderPictureAttributes pa;
136
137	pa.repeat = RepeatPad;	543	pa.repeat = RepeatPad;
138	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
139	Pixmap tmp = XCreatePixmap (dpy, pm, w, h, format->depth);	547	Pixmap tmp_pm = XCreatePixmap (dpy, pm, w, h, format->depth);
140	Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa);	548	Picture tmp = XRenderCreatePicture (dpy, tmp_pm , format, CPRepeat, &pa);
141	XFreePixmap (dpy, tmp);	549	XFreePixmap (dpy, tmp_pm);
142		550
143	if (kernel && params)	551	if (kernel && params)
144	{	552	{
145	size = rh * 2 + 1;	553	size = rh * 2 + 1;
146	get_gaussian_kernel (rh, size, kernel, params);	554	get_gaussian_kernel (rh, size, kernel, params);
147		555
148	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);	556	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
149	XRenderComposite (dpy,	557	XRenderComposite (dpy,
150	PictOpSrc,	558	PictOpSrc,
151	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,
152	None,	575	None,
153	dst,	576	dst,
154	0, 0,	577	0, 0,
155	0, 0,	578	0, 0,
156	0, 0,	579	0, 0,
157	w, h);	580	w, h);
158
159	::swap (src, dst);
160
161	size = rv * 2 + 1;
162	get_gaussian_kernel (rv, size, kernel, params);
163	::swap (params[0], params[1]);
164
165	XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
166	XRenderComposite (dpy,
167	PictOpSrc,
168	src,
169	None,
170	dst,
171	0, 0,
172	0, 0,
173	0, 0,
174	w, h);
175	}	581	}
176		582
177	free (kernel);	583	free (kernel);
178	free (params);	584	free (params);
		585
179	XRenderFreePicture (dpy, src);	586	XRenderFreePicture (dpy, src);
180	XRenderFreePicture (dpy, dst);	587	XRenderFreePicture (dpy, dst);
181	}	588	XRenderFreePicture (dpy, tmp);
182		589
183	static Picture
184	create_xrender_mask (Display *dpy, Drawable drawable, Bool argb)
185	{
186	Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
187
188	XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
189	XRenderPictureAttributes pa;
190	pa.repeat = True;
191	Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
192
193	XFreePixmap (dpy, pixmap);
194
195	return mask;	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;
196	}	610	}
197		611
198	void	612	void
199	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)
200	{	614	{
		615	unshare ();
		616
201	Display *dpy = s->display->dpy;	617	Display *dpy = s->dpy;
202	Picture src = create_xrender_mask (dpy, pm, True);
203	Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);	618	Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
204		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;
205	XRenderColor mask_c;	624	XRenderColor mask_c;
206	mask_c.red = float_to_component (r);	625
207	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))
208	mask_c.blue = float_to_component (b);
209	mask_c.alpha = float_to_component (a);
210	XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1);	627	XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
211		628
212	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);
213	}	643	}
214		644
215	void	645	void
216	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)
217	{	647	{
218	if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL))	648	if (r < 0 \|\| g < 0 \|\| b < 0 \|\| a < 0)
219	return;	649	rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
220		650
221	Display *dpy = s->display->dpy;	651	// premultiply (yeah, these are not exact, sue me or fix it)
222	Picture src = create_xrender_mask (dpy, pm, True);	652	r = (r * (a >> 8)) >> 8;
223	Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);	653	g = (g * (a >> 8)) >> 8;
		654	b = (b * (a >> 8)) >> 8;
224		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;
225	XRenderColor mask_c;	666	XRenderColor mask_c;
226	mask_c.red = float_to_component (r);
227	mask_c.green = float_to_component (g);
228	mask_c.blue = float_to_component (b);
229	mask_c.alpha = float_to_component (a);
230	XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1);
231		667
232	XRenderComposite (dpy, PictOpMultiply, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);	668	if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
233	}
234
235	bool
236	rxvt_img::render_pixbuf (GdkPixbuf *pixbuf, int src_x, int src_y, int width, int height, int dst_x, int dst_y)
237	{
238	Display *dpy = s->display->dpy;
239
240	if (s->visual->c_class != TrueColor)
241	return false;
242
243	uint32_t red_mask, green_mask, blue_mask, alpha_mask;
244
245	red_mask = (uint32_t)format->direct.redMask << format->direct.red;
246	green_mask = (uint32_t)format->direct.greenMask << format->direct.green;
247	blue_mask = (uint32_t)format->direct.blueMask << format->direct.blue;
248	alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
249
250	int width_r = ecb_popcount32 (red_mask);
251	int width_g = ecb_popcount32 (green_mask);
252	int width_b = ecb_popcount32 (blue_mask);
253	int width_a = ecb_popcount32 (alpha_mask);
254
255	if (width_r > 8 \|\| width_g > 8 \|\| width_b > 8 \|\| width_a > 8)
256	return false;
257
258	int sh_r = ecb_ctz32 (red_mask);
259	int sh_g = ecb_ctz32 (green_mask);
260	int sh_b = ecb_ctz32 (blue_mask);
261	int sh_a = ecb_ctz32 (alpha_mask);
262
263	if (width > 32767 \|\| height > 32767)
264	return false;
265
266	XImage *ximage = XCreateImage (dpy, s->visual, format->depth, ZPixmap, 0, 0,
267	width, height, 32, 0);
268	if (!ximage)
269	return false;
270
271	if (height > INT_MAX / ximage->bytes_per_line
272	\|\| !(ximage->data = (char )malloc (height ximage->bytes_per_line)))
273	{
274	XDestroyImage (ximage);
275	return false;
276	}
277
278	GC gc = XCreateGC (dpy, pm, 0, 0);
279
280	ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
281
282	int rowstride = gdk_pixbuf_get_rowstride (pixbuf);
283	int channels = gdk_pixbuf_get_n_channels (pixbuf);
284	unsigned char row = gdk_pixbuf_get_pixels (pixbuf) + src_y rowstride + src_x * channels;
285	char *line = ximage->data;
286
287	rgba c (0, 0, 0);
288
289	if (channels == 4 && alpha_mask == 0)
290	{
291	//pix_colors[Color_bg].get (c);
292	//TODO
293	c.r = 0xffff; c.g = 0xc0c0; c.b = 0xcbcb;//D
294	c.r >>= 8;
295	c.g >>= 8;
296	c.b >>= 8;
297	}
298
299	for (int y = 0; y < height; y++)
300	{
301	for (int x = 0; x < width; x++)
302	{	669	{
303	unsigned char pixel = row + x channels;	670	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &mask_c, 0, 0, 1, 1);
304	uint32_t value;	671	XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
305	unsigned char r, g, b, a;
306
307	if (channels == 4)
308	{
309	a = pixel[3];
310	r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
311	g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
312	b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
313	}
314	else
315	{
316	a = 0xff;
317	r = pixel[0];
318	g = pixel[1];
319	b = pixel[2];
320	}
321
322	value = ((r >> (8 - width_r)) << sh_r)
323	\| ((g >> (8 - width_g)) << sh_g)
324	\| ((b >> (8 - width_b)) << sh_b)
325	\| ((a >> (8 - width_a)) << sh_a);
326
327	if (ximage->bits_per_pixel == 32)
328	((uint32_t *)line)[x] = value;
329	else
330	XPutPixel (ximage, x, y, value);
331	}	672	}
332
333	row += rowstride;
334	line += ximage->bytes_per_line;
335	}	673	}
336		674
337	XPutImage (dpy, pm, gc, ximage, 0, 0, dst_x, dst_y, width, height);	675	::swap (img->ref, ref);
338	XDestroyImage (ximage);	676	::swap (img->pm , pm );
339	XFreeGC (dpy, gc);
340		677
341	return true;	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);
342	}	692	}
343		693
344	rxvt_img *	694	rxvt_img *
345	rxvt_img::clone ()	695	rxvt_img::clone ()
346	{	696	{
347	rxvt_img *img = new rxvt_img (s, format, w, h);	697	return new rxvt_img (*this);
		698	}
348		699
349	GC gc = XCreateGC (s->display->dpy, pm, 0, 0);	700	rxvt_img *
350	XCopyArea (s->display->dpy, pm, img->pm, gc, 0, 0, w, h, 0, 0);	701	rxvt_img::reify ()
351	XFreeGC (s->display->dpy, gc);	702	{
		703	if (x == 0 && y == 0 && w == ref->w && h == ref->h)
		704	return clone ();
		705
		706	Display *dpy = s->dpy;
		707
		708	// add an alpha channel if...
		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
		712
		713	composer cc (this, new rxvt_img (s, alpha ? find_alpha_format_for (s->dpy, format) : format,
		714	0, 0, w, h, repeat));
		715
		716	if (alpha)
		717	{
		718	XRenderColor rc = { 0, 0, 0, 0 };
		719	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
		720	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
		721	}
		722	else
		723	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
		724
		725	return cc;
		726	}
		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)
		737	{
		738	img->w = width;
		739	img->h = height;
		740
		741	rxvt_img *img2 = img->reify ();
		742	delete img;
		743	img = img2;
		744	}
352		745
353	return img;	746	return img;
354	}	747	}
355		748
356	rxvt_img *	749	rxvt_img *
357	rxvt_img::sub_rect (int x, int y, int width, int height, int repeat)	750	rxvt_img::transform (const nv matrix[3][3])
358	{	751	{
359	rxvt_img *img = new rxvt_img (s, format, width, height);	752	return transform (mat3x3 (&matrix[0][0]));
360
361	Display *dpy = s->display->dpy;
362	XRenderPictureAttributes pa;
363	pa.repeat = repeat;
364	Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
365	Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
366
367	XRenderComposite (dpy, PictOpSrc, src, None, dst, x, y, 0, 0, 0, 0, width, height);
368
369	XRenderFreePicture (dpy, src);
370	XRenderFreePicture (dpy, dst);
371
372	return img;
373	}	753	}
374		754
375	rxvt_img *	755	rxvt_img *
376	rxvt_img::transform (int new_width, int new_height, double matrix[9], int repeat)	756	rxvt_img::transform (const nv *matrix)
377	{	757	{
378	rxvt_img *img = new rxvt_img (s, format, new_width, new_height);	758	mat3x3 m (matrix);
379		759
380	Display *dpy = s->display->dpy;	760	// calculate new pixel bounding box coordinates
381	XRenderPictureAttributes pa;	761	nv rmin[2], rmax[2];
382	pa.repeat = repeat;	762
383	Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);	763	for (int i = 0; i < 2; ++i)
384	Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);	764	{
		765	nv v;
		766
		767	v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v;
		768	v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v);
		769	v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
		770	v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
		771	}
		772
		773	float sx = rmin [0] - x;
		774	float sy = rmin [1] - y;
		775
		776	// TODO: adjust matrix for subpixel accuracy
		777	int nx = floor (rmin [0]);
		778	int ny = floor (rmin [1]);
		779
		780	int new_width = ceil (rmax [0] - rmin [0]);
		781	int new_height = ceil (rmax [1] - rmin [1]);
		782
		783	mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
		784
		785	composer cc (this, new rxvt_img (s, format, nx, ny, new_width, new_height, repeat));
385		786
386	XTransform xfrm;	787	XTransform xfrm;
387		788
388	for (int i = 0; i < 3; ++i)	789	for (int i = 0; i < 3; ++i)
389	for (int j = 0; j < 3; ++j)	790	for (int j = 0; j < 3; ++j)
390	xfrm.matrix [i][j] = XDoubleToFixed (matrix [i * 3 + j]);	791	xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
391		792
392	XRenderSetPictureFilter (dpy, src, "good", 0, 0);	793	XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
393	XRenderSetPictureTransform (dpy, src, &xfrm);	794	XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
394	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);
395		796
396	XRenderFreePicture (dpy, src);	797	return cc;
397	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;
398		813
399	return img;	814	return img;
400	}	815	}
401		816
402	rxvt_img *	817	rxvt_img *
403	rxvt_img::scale (int new_width, int new_height)	818	rxvt_img::rotate (int cx, int cy, nv phi)
404	{	819	{
405	double matrix[9] = {	820	#if 0
406	w / (double)new_width, 0, 0,
407	0, h / (double)new_height, 0,
408	0, 0, 1
409	};
410
411	return transform (new_width, new_height, matrix);
412	}
413
414	rxvt_img *
415	rxvt_img::rotate (int new_width, int new_height, int x, int y, double phi, int repeat)
416	{
417	double s = sin (phi);
418	double c = cos (phi);
419
420	double matrix[9] = {
421	c, -s, -c * x + s * y + x,	821	{ c, -s, cx - c * cx + s * cy },
422	s, c, -s * x - c * y + y,	822	{ s, c, cy - s * cx - c * cy },
423	0, 0, 1	823	{ 0, 0, 1 }
424	};	824	#endif
425		825
426	return transform (new_width, new_height, matrix, repeat);	826	move (-cx, -cy);
427	}	827	rxvt_img *img = transform (mat3x3::rotate (phi));
428		828	move ( cx, cy);
429	rxvt_img *	829	img->move (cx, cy);
430	rxvt_img::convert_to (XRenderPictFormat *new_format)
431	{
432	rxvt_img *img = new rxvt_img (s, new_format, w, h);
433
434	Display *dpy = s->display->dpy;
435	Picture src = XRenderCreatePicture (dpy, pm, format, 0, 0);
436	Picture dst = XRenderCreatePicture (dpy, img->pm, new_format, 0, 0);
437
438	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);
439
440	XRenderFreePicture (dpy, src);
441	XRenderFreePicture (dpy, dst);
442		830
443	return img;	831	return img;
444	}	832	}
445		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	rxvt_img *img = new_empty ();
		874
		875	composer cc (img);
		876
		877	XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
		878
		879	for (int i = 0; i < nparams; ++i)
		880	xparams [i] = XDoubleToFixed (params [i]);
		881
		882	XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
		883
		884	XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
		885
		886	return cc;
		887	}
		888
446	#endif	889	#endif
447		890

Diff Legend

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

Comparing rxvt-unicode/src/rxvtimg.C (file contents): Revision 1.21 by sf-exg, Tue Jun 5 14:59:44 2012 UTC vs. Revision 1.98 by root, Sun Jun 17 21:58:18 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/rxvtimg.C (file contents):
Revision 1.21 by sf-exg, Tue Jun 5 14:59:44 2012 UTC vs.
Revision 1.98 by root, Sun Jun 17 21:58:18 2012 UTC