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

Comparing rxvt-unicode/src/rxvtimg.C (file contents):
Revision 1.92 by root, Fri Jun 15 18:05:15 2012 UTC vs.
Revision 1.104 by root, Sat Jul 14 08:27:55 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
1	#include <string.h>	24	#include <string.h>
2	#include <math.h>	25	#include <math.h>
3	#include "../config.h"	26	#include "../config.h"
4	#include "rxvt.h"	27	#include "rxvt.h"
5		28
6	#if HAVE_IMG	29	#if HAVE_IMG
7		30
8	typedef rxvt_img::nv nv;	31	typedef rxvt_img::nv nv;
9		32
		33	namespace
		34	{
10	struct mat3x3	35	struct mat3x3
11	{
12	nv v[3][3];
13
14	mat3x3 ()
15	{	36	{
16	}	37	nv v[3][3];
17		38
18	mat3x3 (nv matrix[3][3])	39	mat3x3 ()
19	{	40	{
		41	}
		42
		43	mat3x3 (const nv *matrix)
		44	{
20	memcpy (v, matrix, sizeof (v));	45	memcpy (v, matrix, sizeof (v));
21	}	46	}
22		47
23	mat3x3 (nv v11, nv v12, nv v13, nv v21, nv v22, nv v23, nv v31, nv v32, nv v33)	48	mat3x3 (nv v11, nv v12, nv v13, nv v21, nv v22, nv v23, nv v31, nv v32, nv v33)
24	{	49	{
25	v[0][0] = v11; v[0][1] = v12; v[0][2] = v13;	50	v[0][0] = v11; v[0][1] = v12; v[0][2] = v13;
26	v[1][0] = v21; v[1][1] = v22; v[1][2] = v23;	51	v[1][0] = v21; v[1][1] = v22; v[1][2] = v23;
27	v[2][0] = v31; v[2][1] = v32; v[2][2] = v33;	52	v[2][0] = v31; v[2][1] = v32; v[2][2] = v33;
28	}	53	}
29		54
30	mat3x3 invert ();	55	mat3x3 inverse ();
31		56
32	nv *operator [](int i) { return &v[i][0]; }	57	nv *operator [](int i) { return &v[i][0]; }
33	const nv *operator [](int i) const { return &v[i][0]; }	58	const nv *operator [](int i) const { return &v[i][0]; }
34		59
		60	operator const nv * () const { return &v[0][0]; }
		61	operator nv * () { return &v[0][0]; }
		62
35	// quite inefficient, hopefully gcc pulls the w calc out of any loops	63	// quite inefficient, hopefully gcc pulls the w calc out of any loops
36	nv apply1 (int i, nv x, nv y)	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 ()
37	{	81	{
38	mat3x3 &m = *this;	82	mat3x3 &m = *this;
		83	mat3x3 inv;
39		84
40	nv v = m[i][0] * x + m[i][1] * y + m[i][2];
41	nv w = m[2][0] * x + m[2][1] * y + m[2][2];	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];
42		88
43	return v * (1. / w);	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;
44	}	104	}
45		105
46	static mat3x3 translate (nv x, nv y);
47	};
48
49	mat3x3
50	mat3x3::invert ()
51	{
52	mat3x3 &m = *this;
53	mat3x3 inv;
54
55	nv s0 = m[2][2] * m[1][1] - m[2][1] * m[1][2];
56	nv s1 = m[2][1] * m[0][2] - m[2][2] * m[0][1];
57	nv s2 = m[1][2] * m[0][1] - m[1][1] * m[0][2];
58
59	nv invdet = 1. / (m[0][0] * s0 + m[1][0] * s1 + m[2][0] * s2);
60
61	inv[0][0] = invdet * s0;
62	inv[0][1] = invdet * s1;
63	inv[0][2] = invdet * s2;
64
65	inv[1][0] = invdet * (m[2][0] * m[1][2] - m[2][2] * m[1][0]);
66	inv[1][1] = invdet * (m[2][2] * m[0][0] - m[2][0] * m[0][2]);
67	inv[1][2] = invdet * (m[1][0] * m[0][2] - m[1][2] * m[0][0]);
68
69	inv[2][0] = invdet * (m[2][1] * m[1][0] - m[2][0] * m[1][1]);
70	inv[2][1] = invdet * (m[2][0] * m[0][1] - m[2][1] * m[0][0]);
71	inv[2][2] = invdet * (m[1][1] * m[0][0] - m[1][0] * m[0][1]);
72
73	return inv;
74	}
75
76	static mat3x3	106	static mat3x3
77	operator *(const mat3x3 &a, const mat3x3 &b)	107	operator *(const mat3x3 &a, const mat3x3 &b)
78	{
79	mat3x3 r;
80
81	for (int i = 0; i < 3; ++i)
82	for (int j = 0; j < 3; ++j)
83	r[i][j] = a[i][0] * b[0][j]
84	+ a[i][1] * b[1][j]
85	+ a[i][2] * b[2][j];
86
87	return r;
88	}
89
90	mat3x3
91	mat3x3::translate (nv x, nv y)
92	{
93	return mat3x3 (
94	1, 0, x,
95	0, 1, y,
96	0, 0, 1
97	);
98	}
99
100	#if 0
101	struct pict
102	{
103	Display *dpy;
104	Picture pic;
105
106	operator Picture () const
107	{	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
108	return pic;	117	return r;
109	}	118	}
110		119
111	pict ()	120	mat3x3
112	: pic (0)	121	mat3x3::translate (nv x, nv y)
113	{	122	{
		123	return mat3x3 (
		124	1, 0, x,
		125	0, 1, y,
		126	0, 0, 1
		127	);
114	}	128	}
115		129
116	pict (rxvt_img img, XRenderPictFormat format = 0)	130	mat3x3
117	: dpy (img->s->display->dpy)	131	mat3x3::scale (nv s, nv t)
118	{	132	{
119	XRenderPictureAttributes pa;	133	return mat3x3 (
120	pa.repeat = img->repeat;	134	s, 0, 0,
121	pic = XRenderCreatePicture (dpy, img->pm, format ? format : img->format, CPRepeat, &pa);	135	0, t, 0,
		136	0, 0, 1
		137	);
122	}	138	}
123		139
124	~pict ()	140	// clockwise
		141	mat3x3
		142	mat3x3::rotate (nv phi)
125	{	143	{
126	if (pic)	144	nv s = sin (phi);
127	XRenderFreePicture (dpy, pic);	145	nv c = cos (phi);
		146
		147	return mat3x3 (
		148	c, -s, 0,
		149	s, c, 0,
		150	0, 0, 1
		151	);
128	}	152	}
129	};	153
130	#endif	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 w = 1, int h = 1)
		176	{
		177	Pixmap pixmap = XCreatePixmap (dpy, srcimg->pm, w, h, rgb ? 32 : 8);
		178
		179	XRenderPictFormat *format = XRenderFindStandardFormat (dpy, rgb ? PictStandardARGB32 : PictStandardA8);
		180	XRenderPictureAttributes pa;
		181	pa.repeat = RepeatNormal;
		182	pa.component_alpha = rgb;
		183	msk = XRenderCreatePicture (dpy, pixmap, format, CPRepeat \| CPComponentAlpha, &pa);
		184
		185	XFreePixmap (dpy, pixmap);
		186
		187	ecb_assume (msk);
		188	}
		189
		190	// CreateSolidFill creates a very very very weird picture
		191	void mask (const rgba &c)
		192	{
		193	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	}
131		229
132	static XRenderPictFormat *	230	static XRenderPictFormat *
133	find_alpha_format_for (Display dpy, XRenderPictFormat format)	231	find_alpha_format_for (Display dpy, XRenderPictFormat format)
134	{	232	{
135	if (format->direct.alphaMask)	233	if (format->direct.alphaMask)
162	}	260	}
163		261
164	rxvt_img *	262	rxvt_img *
165	rxvt_img::new_from_root (rxvt_screen *s)	263	rxvt_img::new_from_root (rxvt_screen *s)
166	{	264	{
167	Display *dpy = s->display->dpy;	265	Display *dpy = s->dpy;
168	unsigned int root_pm_w, root_pm_h;	266	unsigned int root_pm_w, root_pm_h;
169	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]);
170	if (root_pixmap == None)	268	if (root_pixmap == None)
171	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]);
172		270
173	if (root_pixmap == None)	271	if (root_pixmap == None)
174	return 0;	272	return 0;
175		273
176	Window wdummy;	274	Window wdummy;
…		…
199	# if HAVE_PIXBUF	297	# if HAVE_PIXBUF
200		298
201	rxvt_img *	299	rxvt_img *
202	rxvt_img::new_from_pixbuf (rxvt_screen s, GdkPixbuf pb)	300	rxvt_img::new_from_pixbuf (rxvt_screen s, GdkPixbuf pb)
203	{	301	{
204	Display *dpy = s->display->dpy;	302	Display *dpy = s->dpy;
205		303
206	int width = gdk_pixbuf_get_width (pb);	304	int width = gdk_pixbuf_get_width (pb);
207	int height = gdk_pixbuf_get_height (pb);	305	int height = gdk_pixbuf_get_height (pb);
208		306
209	if (width > 32767 \|\| height > 32767) // well, we could upload in chunks	307	if (width > 32767 \|\| height > 32767) // well, we could upload in chunks
…		…
251	for (int y = 0; y < height; y++)	349	for (int y = 0; y < height; y++)
252	{	350	{
253	unsigned char *src = row;	351	unsigned char *src = row;
254	uint32_t dst = (uint32_t )line;	352	uint32_t dst = (uint32_t )line;
255		353
256	if (!pb_has_alpha)
257	for (int x = 0; x < width; x++)	354	for (int x = 0; x < width; x++)
258	{	355	{
259	uint8_t r = *src++;	356	uint8_t r = *src++;
260	uint8_t g = *src++;	357	uint8_t g = *src++;
261	uint8_t b = *src++;	358	uint8_t b = *src++;
		359	uint8_t a = *src;
262		360
		361	// this is done so it can be jump-free, but newer gcc's clone inner the loop
		362	a = pb_has_alpha ? a : 255;
		363	src += pb_has_alpha;
		364
		365	r = (r * a + 127) / 255;
		366	g = (g * a + 127) / 255;
		367	b = (b * a + 127) / 255;
		368
263	uint32_t v = (255 << 24) \| (r << 16) \| (g << 8) \| b;	369	uint32_t v = (a << 24) \| (r << 16) \| (g << 8) \| b;
264		370
265	if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch)	371	if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch)
266	v = ecb_bswap32 (v);	372	v = ecb_bswap32 (v);
267		373
268	*dst++ = v;	374	*dst++ = v;
269	}	375	}
270	else
271	for (int x = 0; x < width; x++)
272	{
273	uint32_t v = (uint32_t )src; src += 4;
274
275	if (ecb_big_endian ())
276	v = ecb_bswap32 (v);
277
278	v = ecb_rotl32 (v, 8); // abgr to bgra
279
280	if (!byte_order_mismatch)
281	v = ecb_bswap32 (v);
282
283	*dst++ = v;
284	}
285		376
286	row += rowstride;	377	row += rowstride;
287	line += xi.bytes_per_line;	378	line += xi.bytes_per_line;
288	}	379	}
289		380
…		…
322	{	413	{
323	if (--ref->cnt)	414	if (--ref->cnt)
324	return;	415	return;
325		416
326	if (pm && ref->ours)	417	if (pm && ref->ours)
327	XFreePixmap (s->display->dpy, pm);	418	XFreePixmap (s->dpy, pm);
328		419
329	delete ref;	420	delete ref;
330	}	421	}
331		422
332	rxvt_img::~rxvt_img ()	423	rxvt_img::~rxvt_img ()
…		…
335	}	426	}
336		427
337	void	428	void
338	rxvt_img::alloc ()	429	rxvt_img::alloc ()
339	{	430	{
340	pm = XCreatePixmap (s->display->dpy, s->display->root, w, h, format->depth);	431	pm = XCreatePixmap (s->dpy, s->display->root, w, h, format->depth);
341	ref = new pixref (w, h);	432	ref = new pixref (w, h);
		433	}
		434
		435	rxvt_img *
		436	rxvt_img::new_empty ()
		437	{
		438	rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat);
		439	img->alloc ();
		440
		441	return img;
342	}	442	}
343		443
344	Picture	444	Picture
345	rxvt_img::picture ()	445	rxvt_img::picture ()
346	{	446	{
347	Display *dpy = s->display->dpy;	447	Display *dpy = s->dpy;
348		448
349	XRenderPictureAttributes pa;	449	XRenderPictureAttributes pa;
350	pa.repeat = repeat;	450	pa.repeat = repeat;
351	Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);	451	Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
352		452
…		…
357	rxvt_img::unshare ()	457	rxvt_img::unshare ()
358	{	458	{
359	if (ref->cnt == 1 && ref->ours)	459	if (ref->cnt == 1 && ref->ours)
360	return;	460	return;
361		461
362	Pixmap pm2 = XCreatePixmap (s->display->dpy, s->display->root, ref->w, ref->h, format->depth);	462	Pixmap pm2 = XCreatePixmap (s->dpy, s->display->root, ref->w, ref->h, format->depth);
363	GC gc = XCreateGC (s->display->dpy, pm, 0, 0);	463	GC gc = XCreateGC (s->dpy, pm, 0, 0);
364	XCopyArea (s->display->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);	464	XCopyArea (s->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);
365	XFreeGC (s->display->dpy, gc);	465	XFreeGC (s->dpy, gc);
366		466
367	destroy ();	467	destroy ();
368		468
369	pm = pm2;	469	pm = pm2;
370	ref = new pixref (ref->w, ref->h);	470	ref = new pixref (ref->w, ref->h);
371	}	471	}
372		472
373	void	473	void
		474	rxvt_img::fill (const rgba &c, int x, int y, int w, int h)
		475	{
		476	XRenderColor rc = { c.r, c.g, c.b, c.a };
		477
		478	Display *dpy = s->dpy;
		479	Picture src = picture ();
		480	XRenderFillRectangle (dpy, PictOpSrc, src, &rc, x, y, w, h);
		481	XRenderFreePicture (dpy, src);
		482	}
		483
		484	void
374	rxvt_img::fill (const rgba &c)	485	rxvt_img::fill (const rgba &c)
375	{	486	{
376	XRenderColor rc = { c.r, c.g, c.b, c.a };	487	fill (c, 0, 0, w, h);
377
378	Display *dpy = s->display->dpy;
379	Picture src = picture ();
380	XRenderFillRectangle (dpy, PictOpSrc, src, &rc, 0, 0, w, h);
381	XRenderFreePicture (dpy, src);
382	}	488	}
383		489
384	void	490	void
385	rxvt_img::add_alpha ()	491	rxvt_img::add_alpha ()
386	{	492	{
387	if (format->direct.alphaMask)	493	if (format->direct.alphaMask)
388	return;	494	return;
389		495
390	Display *dpy = s->display->dpy;
391
392	rxvt_img *img = new rxvt_img (s, find_alpha_format_for (dpy, format), x, y, w, h, repeat);	496	composer cc (this, new rxvt_img (s, find_alpha_format_for (s->dpy, format), x, y, w, h, repeat));
393	img->alloc ();
394
395	Picture src = picture ();
396	Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
397		497
398	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);	498	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
399		499
400	XRenderFreePicture (dpy, src);	500	rxvt_img *img = cc;
401	XRenderFreePicture (dpy, dst);
402		501
403	::swap (img->ref, ref);	502	::swap (img->ref, ref);
404	::swap (img->pm , pm );	503	::swap (img->pm , pm );
405		504
406	delete img;	505	delete img;
…		…
431	rxvt_img::blur (int rh, int rv)	530	rxvt_img::blur (int rh, int rv)
432	{	531	{
433	if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))	532	if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))
434	return clone ();	533	return clone ();
435		534
436	Display *dpy = s->display->dpy;	535	Display *dpy = s->dpy;
437	int size = max (rh, rv) * 2 + 1;	536	int size = max (rh, rv) * 2 + 1;
438	nv kernel = (nv )malloc (size * sizeof (nv));	537	nv kernel = (nv )malloc (size * sizeof (nv));
439	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	538	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));
440	rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat);	539	rxvt_img *img = new_empty ();
441	img->alloc ();
442		540
443	XRenderPictureAttributes pa;	541	XRenderPictureAttributes pa;
444	pa.repeat = RepeatPad;	542	pa.repeat = RepeatPad;
445	Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);	543	Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
446	Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);	544	Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
…		…
489	XRenderFreePicture (dpy, tmp);	587	XRenderFreePicture (dpy, tmp);
490		588
491	return img;	589	return img;
492	}	590	}
493		591
494	static Picture	592	rxvt_img *
495	create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)	593	rxvt_img::muladd (nv mul, nv add)
496	{	594	{
497	Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);	595	// STEP 1: double the image width, fill all odd columns with white (==1)
498		596
499	XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);	597	composer cc (this, new rxvt_img (s, format, 0, 0, w * 2, h, repeat));
500	XRenderPictureAttributes pa;
501	pa.repeat = RepeatNormal;
502	pa.component_alpha = component_alpha;
503	Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat \| CPComponentAlpha, &pa);
504		598
505	XFreePixmap (dpy, pixmap);	599	// why the hell does XRenderSetPictureTransform want a writable matrix :(
		600	// that keeps us from just static const'ing this matrix.
		601	XTransform h_double = {
		602	0x08000, 0, 0,
		603	0, 0x10000, 0,
		604	0, 0, 0x10000
		605	};
506		606
507	return mask;	607	XRenderSetPictureFilter (cc.dpy, cc.src, "nearest", 0, 0);
508	}	608	XRenderSetPictureTransform (cc.dpy, cc.src, &h_double);
		609	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
509		610
510	static void	611	cc.mask (false, 2, 1);
		612
		613	static const XRenderColor c0 = { 0, 0, 0, 0 };
		614	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c0, 0, 0, 1, 1);
		615	static const XRenderColor c1 = { 65535, 65535, 65535, 65535 };
		616	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c1, 1, 0, 1, 1);
		617
		618	Picture white = XRenderCreateSolidFill (cc.dpy, &c1);
		619
		620	XRenderComposite (cc.dpy, PictOpOver, white, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
		621
		622	XRenderFreePicture (cc.dpy, white);
		623
		624	// STEP 2: convolve the image with a 3x1 filter
		625	// a 2x1 filter would obviously suffice, but given the total lack of specification
		626	// for xrender, I expect different xrender implementations to randomly diverge.
		627	// we also halve the image, and hope for the best (again, for lack of specs).
		628	composer cc2 (cc.dstimg);
		629
		630	XFixed kernel [] = {
		631	XDoubleToFixed (3), XDoubleToFixed (1),
		632	XDoubleToFixed (0), XDoubleToFixed (mul), XDoubleToFixed (add)
		633	};
		634
		635	XTransform h_halve = {
		636	0x20000, 0, 0,
		637	0, 0x10000, 0,
		638	0, 0, 0x10000
		639	};
		640
		641	XRenderSetPictureFilter (cc.dpy, cc2.src, "nearest", 0, 0);
		642	XRenderSetPictureTransform (cc.dpy, cc2.src, &h_halve);
		643	XRenderSetPictureFilter (cc.dpy, cc2.src, FilterConvolution, kernel, ecb_array_length (kernel));
		644
		645	XRenderComposite (cc.dpy, PictOpSrc, cc2.src, None, cc2.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
		646
		647	return cc2;
		648	}
		649
		650	ecb_noinline static void
511	extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)	651	extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
512	{	652	{
513	int32_t x = clamp (c, cl0, cl1);	653	int32_t x = clamp (c, cl0, cl1);
514	c -= x;	654	c -= x;
515	xc = x;	655	xc = x;
516	}	656	}
517		657
518	static bool	658	ecb_noinline static bool
519	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)	659	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)
520	{	660	{
521	extract (cl0, cl1, r, xr);	661	extract (cl0, cl1, r, xr);
522	extract (cl0, cl1, g, xg);	662	extract (cl0, cl1, g, xg);
523	extract (cl0, cl1, b, xb);	663	extract (cl0, cl1, b, xb);
…		…
529	void	669	void
530	rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)	670	rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
531	{	671	{
532	unshare ();	672	unshare ();
533		673
534	Display *dpy = s->display->dpy;	674	Display *dpy = s->dpy;
535	Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);	675	Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
536		676
537	// loop should not be needed for brightness, as only -1..1 makes sense	677	// loop should not be needed for brightness, as only -1..1 makes sense
538	//while (r \| g \| b \| a)	678	//while (r \| g \| b \| a)
539	{	679	{
…		…
563	rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)	703	rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
564	{	704	{
565	if (r < 0 \|\| g < 0 \|\| b < 0 \|\| a < 0)	705	if (r < 0 \|\| g < 0 \|\| b < 0 \|\| a < 0)
566	rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");	706	rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
567		707
568	rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat);
569	img->alloc ();
570	img->fill (rgba (0, 0, 0, 0));
571
572	// premultiply (yeah, these are not exact, sue me or fix it)	708	// premultiply (yeah, these are not exact, sue me or fix it)
573	r = (r * (a >> 8)) >> 8;	709	r = (r * (a >> 8)) >> 8;
574	g = (g * (a >> 8)) >> 8;	710	g = (g * (a >> 8)) >> 8;
575	b = (b * (a >> 8)) >> 8;	711	b = (b * (a >> 8)) >> 8;
576		712
577	Display *dpy = s->display->dpy;	713	composer cc (this);
		714	rxvt_img *img = cc;
		715	img->fill (rgba (0, 0, 0, 0));
578		716
579	Picture src = picture ();	717	cc.mask (true);
580	Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
581	Picture mul = create_xrender_mask (dpy, pm, True, True);
582		718
583	//TODO: this operator does not yet implement some useful contrast	719	//TODO: this operator does not yet implement some useful contrast
584	while (r \| g \| b \| a)	720	while (r \| g \| b \| a)
585	{	721	{
586	unsigned short xr, xg, xb, xa;	722	unsigned short xr, xg, xb, xa;
587	XRenderColor mask_c;	723	XRenderColor mask_c;
588		724
589	if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))	725	if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
590	{	726	{
591	XRenderFillRectangle (dpy, PictOpSrc, mul, &mask_c, 0, 0, 1, 1);	727	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &mask_c, 0, 0, 1, 1);
592	XRenderComposite (dpy, PictOpAdd, src, mul, dst, 0, 0, 0, 0, 0, 0, w, h);	728	XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
593	}	729	}
594	}	730	}
595
596	XRenderFreePicture (dpy, mul);
597	XRenderFreePicture (dpy, dst);
598	XRenderFreePicture (dpy, src);
599		731
600	::swap (img->ref, ref);	732	::swap (img->ref, ref);
601	::swap (img->pm , pm );	733	::swap (img->pm , pm );
602		734
603	delete img;	735	delete img;
…		…
606	void	738	void
607	rxvt_img::draw (rxvt_img *img, int op, nv mask)	739	rxvt_img::draw (rxvt_img *img, int op, nv mask)
608	{	740	{
609	unshare ();	741	unshare ();
610		742
611	Display *dpy = s->display->dpy;	743	composer cc (img, this);
612	Picture src = img->picture ();
613	Picture dst = picture ();
614	Picture mask_p = 0;
615		744
616	if (mask != 1.)	745	if (mask != 1.)
617	{	746	cc.mask (rgba (0, 0, 0, float_to_component (mask)));
618	mask_p = create_xrender_mask (dpy, img->pm, False, False);
619	XRenderColor mask_c = { 0, 0, 0, float_to_component (mask) };
620	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
621	}
622		747
623	XRenderComposite (dpy, op, src, mask_p, dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h);	748	XRenderComposite (cc.dpy, op, cc.src, cc.msk, cc.dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h);
624
625	XRenderFreePicture (dpy, src);
626	XRenderFreePicture (dpy, dst);
627
628	if (mask_p)
629	XRenderFreePicture (dpy, mask_p);
630	}	749	}
631		750
632	rxvt_img *	751	rxvt_img *
633	rxvt_img::clone ()	752	rxvt_img::clone ()
634	{	753	{
…		…
638	rxvt_img *	757	rxvt_img *
639	rxvt_img::reify ()	758	rxvt_img::reify ()
640	{	759	{
641	if (x == 0 && y == 0 && w == ref->w && h == ref->h)	760	if (x == 0 && y == 0 && w == ref->w && h == ref->h)
642	return clone ();	761	return clone ();
643
644	Display *dpy = s->display->dpy;
645		762
646	// add an alpha channel if...	763	// add an alpha channel if...
647	bool alpha = !format->direct.alphaMask // pixmap has none yet	764	bool alpha = !format->direct.alphaMask // pixmap has none yet
648	&& (x \|\| y) // we need one because of non-zero offset	765	&& (x \|\| y) // we need one because of non-zero offset
649	&& repeat == RepeatNone; // and we have no good pixels to fill with	766	&& repeat == RepeatNone; // and we have no good pixels to fill with
650		767
651	rxvt_img *img = new rxvt_img (s, alpha ? find_alpha_format_for (dpy, format) : format, 0, 0, w, h, repeat);	768	composer cc (this, new rxvt_img (s, alpha ? find_alpha_format_for (s->dpy, format) : format,
652	img->alloc ();	769	0, 0, w, h, repeat));
653		770
654	Picture src = picture ();	771	if (repeat == RepeatNone)
655	Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
656
657	if (alpha)
658	{	772	{
659	XRenderColor rc = { 0, 0, 0, 0 };	773	XRenderColor rc = { 0, 0, 0, 0 };
660	XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles	774	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
661	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, x, y, ref->w, ref->h);	775	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
662	}	776	}
663	else	777	else
664	XRenderComposite (dpy, PictOpSrc, src, None, dst, -x, -y, 0, 0, 0, 0, w, h);	778	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
665		779
666	XRenderFreePicture (dpy, src);
667	XRenderFreePicture (dpy, dst);
668
669	return img;	780	return cc;
670	}	781	}
671		782
672	rxvt_img *	783	rxvt_img *
673	rxvt_img::sub_rect (int x, int y, int width, int height)	784	rxvt_img::sub_rect (int x, int y, int width, int height)
674	{	785	{
…		…
689		800
690	return img;	801	return img;
691	}	802	}
692		803
693	rxvt_img *	804	rxvt_img *
694	rxvt_img::transform (nv matrix[3][3])	805	rxvt_img::transform (const nv matrix[3][3])
695	{	806	{
		807	return transform (mat3x3 (&matrix[0][0]));
		808	}
		809
		810	rxvt_img *
		811	rxvt_img::transform (const nv *matrix)
		812	{
		813	mat3x3 m (matrix);
		814
696	// calculate new pixel bounding box coordinates	815	// calculate new pixel bounding box coordinates
697	nv r[2], rmin[2], rmax[2];	816	nv rmin[2], rmax[2];
698
699	mat3x3 m (matrix);
700		817
701	for (int i = 0; i < 2; ++i)	818	for (int i = 0; i < 2; ++i)
702	{	819	{
703	nv v;	820	nv v;
704		821
705	v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v; r [i] = v;	822	v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v;
706	v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v);	823	v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v);
707	v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);	824	v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
708	v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);	825	v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
709	}	826	}
710		827
…		…
716	int ny = floor (rmin [1]);	833	int ny = floor (rmin [1]);
717		834
718	int new_width = ceil (rmax [0] - rmin [0]);	835	int new_width = ceil (rmax [0] - rmin [0]);
719	int new_height = ceil (rmax [1] - rmin [1]);	836	int new_height = ceil (rmax [1] - rmin [1]);
720		837
721	m = mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y);	838	mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
722		839
723	mat3x3 inv = m.invert ();	840	composer cc (this, new rxvt_img (s, format, nx, ny, new_width, new_height, repeat));
724
725	rxvt_img *img = new rxvt_img (s, format, nx, ny, new_width, new_height, repeat);
726	img->alloc ();
727
728	Display *dpy = s->display->dpy;
729	Picture src = picture ();
730	Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
731		841
732	XTransform xfrm;	842	XTransform xfrm;
733		843
734	for (int i = 0; i < 3; ++i)	844	for (int i = 0; i < 3; ++i)
735	for (int j = 0; j < 3; ++j)	845	for (int j = 0; j < 3; ++j)
736	xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);	846	xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
737		847
738	XRenderSetPictureFilter (dpy, src, "good", 0, 0);	848	XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
739	XRenderSetPictureTransform (dpy, src, &xfrm);	849	XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
740	XRenderComposite (dpy, PictOpSrc, src, None, dst, sx, sy, 0, 0, 0, 0, new_width, new_height);	850	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
741	#if 1
742	{
743	XRenderColor rc = { 65535,0,0,65535 };
744	XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, new_width, new_height);
745	}{
746	XRenderColor rc = { 0,0,0,65535 };
747	XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 1, 1, new_width - 2, new_height - 2);
748	}
749	XRenderComposite (dpy, PictOpOver, src, None, dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
750	#endif
751		851
752	XRenderFreePicture (dpy, src);
753	XRenderFreePicture (dpy, dst);
754
755	return img;	852	return cc;
756	}	853	}
757		854
758	rxvt_img *	855	rxvt_img *
759	rxvt_img::scale (int new_width, int new_height)	856	rxvt_img::scale (int new_width, int new_height)
760	{	857	{
761	if (w == new_width && h == new_height)	858	if (w == new_width && h == new_height)
762	return clone ();	859	return clone ();
763		860
764	nv matrix[3][3] = {
765	{ new_width / (nv)w, 0, 0 },
766	{ 0, new_height / (nv)h, 0 },
767	{ 0, 0, 1 }
768	};
769
770	int old_repeat_mode = repeat;	861	int old_repeat_mode = repeat;
771	repeat = RepeatPad; // not right, but xrender can't properly scale it seems	862	repeat = RepeatPad; // not right, but xrender can't properly scale it seems
772		863
773	rxvt_img *img = transform (matrix);	864	rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
774		865
775	repeat = old_repeat_mode;	866	repeat = old_repeat_mode;
776	img->repeat = repeat;	867	img->repeat = repeat;
777		868
778	return img;	869	return img;
779	}	870	}
780		871
781	rxvt_img *	872	rxvt_img *
782	rxvt_img::rotate (int cx, int cy, nv phi)	873	rxvt_img::rotate (int cx, int cy, nv phi)
783	{	874	{
784	nv s = sin (phi);
785	nv c = cos (phi);
786
787	nv matrix[3][3] = {
788	#if 0
789	{ c, -s, cx - c * cx + s * cy },
790	{ s, c, cy - s * cx - c * cy },
791	{ 0, 0, 1 }
792	#else
793	{ c, -s, 0 },
794	{ s, c, 0 },
795	{ 0, 0, 1 }
796	#endif
797	};
798
799	move (-cx, -cy);	875	move (-cx, -cy);
800	rxvt_img *img = transform (matrix);	876	rxvt_img *img = transform (mat3x3::rotate (phi));
801	move ( cx, cy);	877	move ( cx, cy);
802	img->move (cx, cy);	878	img->move (cx, cy);
803		879
804	return img;	880	return img;
805	}	881	}
…		…
808	rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)	884	rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
809	{	885	{
810	if (new_format == format)	886	if (new_format == format)
811	return clone ();	887	return clone ();
812		888
813	rxvt_img *img = new rxvt_img (s, new_format, x, y, w, h, repeat);	889	composer cc (this, new rxvt_img (s, new_format, x, y, w, h, repeat));
814	img->alloc ();
815		890
816	Display *dpy = s->display->dpy;
817	Picture src = picture ();
818	Picture dst = XRenderCreatePicture (dpy, img->pm, new_format, 0, 0);
819	int op = PictOpSrc;	891	int op = PictOpSrc;
820		892
821	if (format->direct.alphaMask && !new_format->direct.alphaMask)	893	if (format->direct.alphaMask && !new_format->direct.alphaMask)
822	{	894	{
823	// does it have to be that complicated	895	// does it have to be that complicated
824	XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };	896	XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
825	XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);	897	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
826		898
827	op = PictOpOver;	899	op = PictOpOver;
828	}	900	}
829		901
830	XRenderComposite (dpy, op, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);	902	XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
831		903
832	XRenderFreePicture (dpy, src);
833	XRenderFreePicture (dpy, dst);
834
835	return img;	904	return cc;
836	}	905	}
837		906
838	rxvt_img *	907	rxvt_img *
839	rxvt_img::blend (rxvt_img *img, nv factor)	908	rxvt_img::tint (const rgba &c)
840	{	909	{
841	rxvt_img *img2 = clone ();	910	composer cc (this);
842	Display *dpy = s->display->dpy;	911	cc.mask (true);
843	Picture src = img->picture ();	912	cc.fill (c);
844	Picture dst = XRenderCreatePicture (dpy, img2->pm, img2->format, 0, 0);
845	Picture mask = create_xrender_mask (dpy, img->pm, False, False);
846		913
847	XRenderColor mask_c;
848
849	mask_c.alpha = float_to_component (factor);
850	mask_c.red =
851	mask_c.green =
852	mask_c.blue = 0;
853	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
854
855	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, w, h);	914	XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
856		915
857	XRenderFreePicture (dpy, src);
858	XRenderFreePicture (dpy, dst);
859	XRenderFreePicture (dpy, mask);
860
861	return img2;	916	return cc;
		917	}
		918
		919	rxvt_img *
		920	rxvt_img::filter (const char name, int nparams, nv params)
		921	{
		922	composer cc (this);
		923
		924	XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
		925
		926	for (int i = 0; i < nparams; ++i)
		927	xparams [i] = XDoubleToFixed (params [i]);
		928
		929	XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
		930
		931	XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
		932
		933	return cc;
862	}	934	}
863		935
864	#endif	936	#endif
865		937

Diff Legend

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

Comparing rxvt-unicode/src/rxvtimg.C (file contents): Revision 1.92 by root, Fri Jun 15 18:05:15 2012 UTC vs. Revision 1.104 by root, Sat Jul 14 08:27:55 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/rxvtimg.C (file contents):
Revision 1.92 by root, Fri Jun 15 18:05:15 2012 UTC vs.
Revision 1.104 by root, Sat Jul 14 08:27:55 2012 UTC