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

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

Diff Legend

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

Comparing rxvt-unicode/src/rxvtimg.C (file contents): Revision 1.94 by root, Fri Jun 15 18:10:40 2012 UTC vs. Revision 1.101 by root, Mon Jul 2 03:57:53 2012 UTC

Diff Legend

Comparing rxvt-unicode/src/rxvtimg.C (file contents):
Revision 1.94 by root, Fri Jun 15 18:10:40 2012 UTC vs.
Revision 1.101 by root, Mon Jul 2 03:57:53 2012 UTC