[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.95 by root, Fri Jun 15 18:36:26 2012 UTC

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

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.95 by root, Fri Jun 15 18:36:26 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.95 by root, Fri Jun 15 18:36:26 2012 UTC