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

Comparing rxvt-unicode/src/rxvtimg.C (file contents):
Revision 1.93 by root, Fri Jun 15 18:07:24 2012 UTC vs.
Revision 1.109 by sf-exg, Sat Jul 15 08:16:31 2017 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 3 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->d->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	// the casts are needed in C++11 (see 8.5.1)
		194	XRenderColor rc = {
		195	(unsigned short)(c.r * c.a / 65535),
		196	(unsigned short)(c.g * c.a / 65535),
		197	(unsigned short)(c.b * c.a / 65535),
		198	c.a
		199	};
		200	msk = XRenderCreateSolidFill (dpy, &rc);
		201	ecb_assume (msk);
		202	}
		203
		204	void fill (const rgba &c)
		205	{
		206	XRenderColor rc = {
		207	(unsigned short)(c.r * c.a / 65535),
		208	(unsigned short)(c.g * c.a / 65535),
		209	(unsigned short)(c.b * c.a / 65535),
		210	c.a
		211	};
		212
		213	XRenderFillRectangle (dpy, PictOpSrc, msk, &rc, 0, 0, 1, 1);
		214	}
		215
		216	operator rxvt_img *()
		217	{
		218	return dstimg;
		219	}
		220
		221	ecb_noinline
		222	~composer ()
		223	{
		224	XRenderFreePicture (dpy, src);
		225	XRenderFreePicture (dpy, dst);
		226	if (msk) XRenderFreePicture (dpy, msk);
		227	}
127	}	228	};
128		229	}
129	~pict ()
130	{
131	if (pic)
132	XRenderFreePicture (dpy, pic);
133	}
134	};
135	#endif
136		230
137	static XRenderPictFormat *	231	static XRenderPictFormat *
138	find_alpha_format_for (Display dpy, XRenderPictFormat format)	232	find_alpha_format_for (Display dpy, XRenderPictFormat format)
139	{	233	{
140	if (format->direct.alphaMask)	234	if (format->direct.alphaMask)
…		…
153	// should be a very good fallback	247	// should be a very good fallback
154	return XRenderFindStandardFormat (dpy, PictStandardARGB32);	248	return XRenderFindStandardFormat (dpy, PictStandardARGB32);
155	}	249	}
156		250
157	rxvt_img::rxvt_img (rxvt_screen screen, XRenderPictFormat format, int x, int y, int width, int height, int repeat)	251	rxvt_img::rxvt_img (rxvt_screen screen, XRenderPictFormat format, int x, int y, int width, int height, int repeat)
158	: s(screen), x(x), y(y), w(width), h(height), format(format), repeat(repeat),	252	: d(screen->display), x(x), y(y), w(width), h(height), format(format), repeat(repeat),
159	pm(0), ref(0)	253	pm(0), ref(0)
160	{	254	{
161	}	255	}
162		256
		257	rxvt_img::rxvt_img (rxvt_display display, XRenderPictFormat format, int x, int y, int width, int height, int repeat)
		258	: d(display), x(x), y(y), w(width), h(height), format(format), repeat(repeat),
		259	pm(0), ref(0)
		260	{
		261	}
		262
163	rxvt_img::rxvt_img (const rxvt_img &img)	263	rxvt_img::rxvt_img (const rxvt_img &img)
164	: 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)	264	: d(img.d), x(img.x), y(img.y), w(img.w), h(img.h), format(img.format), repeat(img.repeat), pm(img.pm), ref(img.ref)
165	{	265	{
166	++ref->cnt;	266	++ref->cnt;
167	}	267	}
168		268
169	rxvt_img *	269	rxvt_img *
170	rxvt_img::new_from_root (rxvt_screen *s)	270	rxvt_img::new_from_root (rxvt_screen *s)
171	{	271	{
172	Display *dpy = s->display->dpy;	272	Display *dpy = s->dpy;
173	unsigned int root_pm_w, root_pm_h;	273	unsigned int root_pm_w, root_pm_h;
174	Pixmap root_pixmap = s->display->get_pixmap_property (s->display->xa[XA_XROOTPMAP_ID]);	274	Pixmap root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_XROOTPMAP_ID]);
175	if (root_pixmap == None)	275	if (root_pixmap == None)
176	root_pixmap = s->display->get_pixmap_property (s->display->xa[XA_ESETROOT_PMAP_ID]);	276	root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_ESETROOT_PMAP_ID]);
177		277
178	if (root_pixmap == None)	278	if (root_pixmap == None)
179	return 0;	279	return 0;
180		280
181	Window wdummy;	281	Window wdummy;
…		…
204	# if HAVE_PIXBUF	304	# if HAVE_PIXBUF
205		305
206	rxvt_img *	306	rxvt_img *
207	rxvt_img::new_from_pixbuf (rxvt_screen s, GdkPixbuf pb)	307	rxvt_img::new_from_pixbuf (rxvt_screen s, GdkPixbuf pb)
208	{	308	{
209	Display *dpy = s->display->dpy;	309	Display *dpy = s->dpy;
210		310
211	int width = gdk_pixbuf_get_width (pb);	311	int width = gdk_pixbuf_get_width (pb);
212	int height = gdk_pixbuf_get_height (pb);	312	int height = gdk_pixbuf_get_height (pb);
213		313
214	if (width > 32767 \|\| height > 32767) // well, we could upload in chunks	314	if (width > 32767 \|\| height > 32767) // well, we could upload in chunks
…		…
256	for (int y = 0; y < height; y++)	356	for (int y = 0; y < height; y++)
257	{	357	{
258	unsigned char *src = row;	358	unsigned char *src = row;
259	uint32_t dst = (uint32_t )line;	359	uint32_t dst = (uint32_t )line;
260		360
261	if (!pb_has_alpha)
262	for (int x = 0; x < width; x++)	361	for (int x = 0; x < width; x++)
263	{	362	{
264	uint8_t r = *src++;	363	uint8_t r = *src++;
265	uint8_t g = *src++;	364	uint8_t g = *src++;
266	uint8_t b = *src++;	365	uint8_t b = *src++;
		366	uint8_t a = *src;
267		367
		368	// this is done so it can be jump-free, but newer gcc's clone inner the loop
		369	a = pb_has_alpha ? a : 255;
		370	src += pb_has_alpha;
		371
		372	r = (r * a + 127) / 255;
		373	g = (g * a + 127) / 255;
		374	b = (b * a + 127) / 255;
		375
268	uint32_t v = (255 << 24) \| (r << 16) \| (g << 8) \| b;	376	uint32_t v = (a << 24) \| (r << 16) \| (g << 8) \| b;
269		377
270	if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch)	378	if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch)
271	v = ecb_bswap32 (v);	379	v = ecb_bswap32 (v);
272		380
273	*dst++ = v;	381	*dst++ = v;
274	}	382	}
275	else
276	for (int x = 0; x < width; x++)
277	{
278	uint32_t v = (uint32_t )src; src += 4;
279
280	if (ecb_big_endian ())
281	v = ecb_bswap32 (v);
282
283	v = ecb_rotl32 (v, 8); // abgr to bgra
284
285	if (!byte_order_mismatch)
286	v = ecb_bswap32 (v);
287
288	*dst++ = v;
289	}
290		383
291	row += rowstride;	384	row += rowstride;
292	line += xi.bytes_per_line;	385	line += xi.bytes_per_line;
293	}	386	}
294		387
…		…
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 (d->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 (d->dpy, d->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 (d, 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 = d->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 (d->dpy, d->root, ref->w, ref->h, format->depth);
368	GC gc = XCreateGC (s->display->dpy, pm, 0, 0);	470	GC gc = XCreateGC (d->dpy, pm, 0, 0);
369	XCopyArea (s->display->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);	471	XCopyArea (d->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);
370	XFreeGC (s->display->dpy, gc);	472	XFreeGC (d->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 = d->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;	503	composer cc (this, new rxvt_img (d, find_alpha_format_for (d->dpy, format), x, y, w, h, repeat));
396
397	rxvt_img *img = new rxvt_img (s, find_alpha_format_for (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;
…		…
433	}	534	}
434		535
435	rxvt_img *	536	rxvt_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 (!(d->flags & DISPLAY_HAS_RENDER_CONV))
439	return clone ();	540	return clone ();
440		541
441	Display *dpy = s->display->dpy;	542	Display *dpy = d->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 = rxvt_temp_buf<XFixed> (size + 2);
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);
…		…
485	0, 0,	585	0, 0,
486	w, h);	586	w, h);
487	}	587	}
488		588
489	free (kernel);	589	free (kernel);
490	free (params);
491		590
492	XRenderFreePicture (dpy, src);	591	XRenderFreePicture (dpy, src);
493	XRenderFreePicture (dpy, dst);	592	XRenderFreePicture (dpy, dst);
494	XRenderFreePicture (dpy, tmp);	593	XRenderFreePicture (dpy, tmp);
495		594
496	return img;	595	return img;
497	}	596	}
498		597
499	static Picture	598	rxvt_img *
500	create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)	599	rxvt_img::muladd (nv mul, nv add)
501	{	600	{
502	Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);	601	// STEP 1: double the image width, fill all odd columns with white (==1)
503		602
504	XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);	603	composer cc (this, new rxvt_img (d, 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		604
510	XFreePixmap (dpy, pixmap);	605	// why the hell does XRenderSetPictureTransform want a writable matrix :(
		606	// that keeps us from just static const'ing this matrix.
		607	XTransform h_double = {
		608	0x08000, 0, 0,
		609	0, 0x10000, 0,
		610	0, 0, 0x10000
		611	};
511		612
512	return mask;	613	XRenderSetPictureFilter (cc.dpy, cc.src, "nearest", 0, 0);
513	}	614	XRenderSetPictureTransform (cc.dpy, cc.src, &h_double);
		615	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
514		616
515	static void	617	cc.mask (false, 2, 1);
		618
		619	static const XRenderColor c0 = { 0, 0, 0, 0 };
		620	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c0, 0, 0, 1, 1);
		621	static const XRenderColor c1 = { 65535, 65535, 65535, 65535 };
		622	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c1, 1, 0, 1, 1);
		623
		624	Picture white = XRenderCreateSolidFill (cc.dpy, &c1);
		625
		626	XRenderComposite (cc.dpy, PictOpOver, white, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
		627
		628	XRenderFreePicture (cc.dpy, white);
		629
		630	// STEP 2: convolve the image with a 3x1 filter
		631	// a 2x1 filter would obviously suffice, but given the total lack of specification
		632	// for xrender, I expect different xrender implementations to randomly diverge.
		633	// we also halve the image, and hope for the best (again, for lack of specs).
		634	composer cc2 (cc.dstimg);
		635
		636	XFixed kernel [] = {
		637	XDoubleToFixed (3), XDoubleToFixed (1),
		638	XDoubleToFixed (0), XDoubleToFixed (mul), XDoubleToFixed (add)
		639	};
		640
		641	XTransform h_halve = {
		642	0x20000, 0, 0,
		643	0, 0x10000, 0,
		644	0, 0, 0x10000
		645	};
		646
		647	XRenderSetPictureFilter (cc.dpy, cc2.src, "nearest", 0, 0);
		648	XRenderSetPictureTransform (cc.dpy, cc2.src, &h_halve);
		649	XRenderSetPictureFilter (cc.dpy, cc2.src, FilterConvolution, kernel, ecb_array_length (kernel));
		650
		651	XRenderComposite (cc.dpy, PictOpSrc, cc2.src, None, cc2.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
		652
		653	return cc2;
		654	}
		655
		656	ecb_noinline static void
516	extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)	657	extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
517	{	658	{
518	int32_t x = clamp (c, cl0, cl1);	659	int32_t x = clamp (c, cl0, cl1);
519	c -= x;	660	c -= x;
520	xc = x;	661	xc = x;
521	}	662	}
522		663
523	static bool	664	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)	665	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	{	666	{
526	extract (cl0, cl1, r, xr);	667	extract (cl0, cl1, r, xr);
527	extract (cl0, cl1, g, xg);	668	extract (cl0, cl1, g, xg);
528	extract (cl0, cl1, b, xb);	669	extract (cl0, cl1, b, xb);
…		…
534	void	675	void
535	rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)	676	rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
536	{	677	{
537	unshare ();	678	unshare ();
538		679
539	Display *dpy = s->display->dpy;	680	Display *dpy = d->dpy;
540	Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);	681	Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
541		682
542	// loop should not be needed for brightness, as only -1..1 makes sense	683	// loop should not be needed for brightness, as only -1..1 makes sense
543	//while (r \| g \| b \| a)	684	//while (r \| g \| b \| a)
544	{	685	{
…		…
568	rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)	709	rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
569	{	710	{
570	if (r < 0 \|\| g < 0 \|\| b < 0 \|\| a < 0)	711	if (r < 0 \|\| g < 0 \|\| b < 0 \|\| a < 0)
571	rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");	712	rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
572		713
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)	714	// premultiply (yeah, these are not exact, sue me or fix it)
578	r = (r * (a >> 8)) >> 8;	715	r = (r * (a >> 8)) >> 8;
579	g = (g * (a >> 8)) >> 8;	716	g = (g * (a >> 8)) >> 8;
580	b = (b * (a >> 8)) >> 8;	717	b = (b * (a >> 8)) >> 8;
581		718
582	Display *dpy = s->display->dpy;	719	composer cc (this);
		720	rxvt_img *img = cc;
		721	img->fill (rgba (0, 0, 0, 0));
583		722
584	Picture src = picture ();	723	cc.mask (true);
585	Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
586	Picture mul = create_xrender_mask (dpy, pm, True, True);
587		724
588	//TODO: this operator does not yet implement some useful contrast	725	//TODO: this operator does not yet implement some useful contrast
589	while (r \| g \| b \| a)	726	while (r \| g \| b \| a)
590	{	727	{
591	unsigned short xr, xg, xb, xa;	728	unsigned short xr, xg, xb, xa;
592	XRenderColor mask_c;	729	XRenderColor mask_c;
593		730
594	if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))	731	if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
595	{	732	{
596	XRenderFillRectangle (dpy, PictOpSrc, mul, &mask_c, 0, 0, 1, 1);	733	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);	734	XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
598	}	735	}
599	}	736	}
600
601	XRenderFreePicture (dpy, mul);
602	XRenderFreePicture (dpy, dst);
603	XRenderFreePicture (dpy, src);
604		737
605	::swap (img->ref, ref);	738	::swap (img->ref, ref);
606	::swap (img->pm , pm );	739	::swap (img->pm , pm );
607		740
608	delete img;	741	delete img;
…		…
611	void	744	void
612	rxvt_img::draw (rxvt_img *img, int op, nv mask)	745	rxvt_img::draw (rxvt_img *img, int op, nv mask)
613	{	746	{
614	unshare ();	747	unshare ();
615		748
616	Display *dpy = s->display->dpy;	749	composer cc (img, this);
617	Picture src = img->picture ();
618	Picture dst = picture ();
619	Picture mask_p = 0;
620		750
621	if (mask != 1.)	751	if (mask != 1.)
622	{	752	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		753
628	XRenderComposite (dpy, op, src, mask_p, dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h);	754	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	}	755	}
636		756
637	rxvt_img *	757	rxvt_img *
638	rxvt_img::clone ()	758	rxvt_img::clone ()
639	{	759	{
…		…
643	rxvt_img *	763	rxvt_img *
644	rxvt_img::reify ()	764	rxvt_img::reify ()
645	{	765	{
646	if (x == 0 && y == 0 && w == ref->w && h == ref->h)	766	if (x == 0 && y == 0 && w == ref->w && h == ref->h)
647	return clone ();	767	return clone ();
648
649	Display *dpy = s->display->dpy;
650		768
651	// add an alpha channel if...	769	// add an alpha channel if...
652	bool alpha = !format->direct.alphaMask // pixmap has none yet	770	bool alpha = !format->direct.alphaMask // pixmap has none yet
653	&& (x \|\| y) // we need one because of non-zero offset	771	&& (x \|\| y) // we need one because of non-zero offset
654	&& repeat == RepeatNone; // and we have no good pixels to fill with	772	&& repeat == RepeatNone; // and we have no good pixels to fill with
655		773
656	rxvt_img *img = new rxvt_img (s, alpha ? find_alpha_format_for (dpy, format) : format, 0, 0, w, h, repeat);	774	composer cc (this, new rxvt_img (d, alpha ? find_alpha_format_for (d->dpy, format) : format,
657	img->alloc ();	775	0, 0, w, h, repeat));
658		776
659	Picture src = picture ();	777	if (repeat == RepeatNone)
660	Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
661
662	if (alpha)
663	{	778	{
664	XRenderColor rc = { 0, 0, 0, 0 };	779	XRenderColor rc = { 0, 0, 0, 0 };
665	XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles	780	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);	781	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
667	}	782	}
668	else	783	else
669	XRenderComposite (dpy, PictOpSrc, src, None, dst, -x, -y, 0, 0, 0, 0, w, h);	784	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
670		785
671	XRenderFreePicture (dpy, src);
672	XRenderFreePicture (dpy, dst);
673
674	return img;	786	return cc;
675	}	787	}
676		788
677	rxvt_img *	789	rxvt_img *
678	rxvt_img::sub_rect (int x, int y, int width, int height)	790	rxvt_img::sub_rect (int x, int y, int width, int height)
679	{	791	{
…		…
694		806
695	return img;	807	return img;
696	}	808	}
697		809
698	rxvt_img *	810	rxvt_img *
699	rxvt_img::transform (nv matrix[3][3])	811	rxvt_img::transform (const nv matrix[3][3])
700	{	812	{
		813	return transform (mat3x3 (&matrix[0][0]));
		814	}
		815
		816	rxvt_img *
		817	rxvt_img::transform (const nv *matrix)
		818	{
		819	mat3x3 m (matrix);
		820
701	// calculate new pixel bounding box coordinates	821	// calculate new pixel bounding box coordinates
702	nv r[2], rmin[2], rmax[2];	822	nv rmin[2], rmax[2];
703
704	mat3x3 m (matrix);
705		823
706	for (int i = 0; i < 2; ++i)	824	for (int i = 0; i < 2; ++i)
707	{	825	{
708	nv v;	826	nv v;
709		827
710	v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v; r [i] = v;	828	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);	829	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);	830	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);	831	v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
714	}	832	}
715		833
…		…
721	int ny = floor (rmin [1]);	839	int ny = floor (rmin [1]);
722		840
723	int new_width = ceil (rmax [0] - rmin [0]);	841	int new_width = ceil (rmax [0] - rmin [0]);
724	int new_height = ceil (rmax [1] - rmin [1]);	842	int new_height = ceil (rmax [1] - rmin [1]);
725		843
726	m = mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y);	844	mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
727		845
728	mat3x3 inv = m.invert ();	846	composer cc (this, new rxvt_img (d, 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		847
737	XTransform xfrm;	848	XTransform xfrm;
738		849
739	for (int i = 0; i < 3; ++i)	850	for (int i = 0; i < 3; ++i)
740	for (int j = 0; j < 3; ++j)	851	for (int j = 0; j < 3; ++j)
741	xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);	852	xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
742		853
743	XRenderSetPictureFilter (dpy, src, "good", 0, 0);	854	XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
744	XRenderSetPictureTransform (dpy, src, &xfrm);	855	XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
745	XRenderComposite (dpy, PictOpSrc, src, None, dst, sx, sy, 0, 0, 0, 0, new_width, new_height);	856	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
746	#if 1
747	{
748	XRenderColor rc = { 65535,0,0,65535 };
749	XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, new_width, new_height);
750	}{
751	XRenderColor rc = { 0,0,0,65535 };
752	XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 1, 1, new_width - 2, new_height - 2);
753	}
754	XRenderComposite (dpy, PictOpOver, src, None, dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
755	#endif
756		857
757	XRenderFreePicture (dpy, src);
758	XRenderFreePicture (dpy, dst);
759
760	return img;	858	return cc;
761	}	859	}
762		860
763	rxvt_img *	861	rxvt_img *
764	rxvt_img::scale (int new_width, int new_height)	862	rxvt_img::scale (int new_width, int new_height)
765	{	863	{
766	if (w == new_width && h == new_height)	864	if (w == new_width && h == new_height)
767	return clone ();	865	return clone ();
768		866
769	nv matrix[3][3] = {
770	{ new_width / (nv)w, 0, 0 },
771	{ 0, new_height / (nv)h, 0 },
772	{ 0, 0, 1 }
773	};
774
775	int old_repeat_mode = repeat;	867	int old_repeat_mode = repeat;
776	repeat = RepeatPad; // not right, but xrender can't properly scale it seems	868	repeat = RepeatPad; // not right, but xrender can't properly scale it seems
777		869
778	rxvt_img *img = transform (matrix);	870	rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
779		871
780	repeat = old_repeat_mode;	872	repeat = old_repeat_mode;
781	img->repeat = repeat;	873	img->repeat = repeat;
782		874
783	return img;	875	return img;
784	}	876	}
785		877
786	rxvt_img *	878	rxvt_img *
787	rxvt_img::rotate (int cx, int cy, nv phi)	879	rxvt_img::rotate (int cx, int cy, nv phi)
788	{	880	{
789	nv s = sin (phi);
790	nv c = cos (phi);
791
792	nv matrix[3][3] = {
793	#if 0
794	{ c, -s, cx - c * cx + s * cy },
795	{ s, c, cy - s * cx - c * cy },
796	{ 0, 0, 1 }
797	#else
798	{ c, -s, 0 },
799	{ s, c, 0 },
800	{ 0, 0, 1 }
801	#endif
802	};
803
804	move (-cx, -cy);	881	move (-cx, -cy);
805	rxvt_img *img = transform (matrix);	882	rxvt_img *img = transform (mat3x3::rotate (phi));
806	move ( cx, cy);	883	move ( cx, cy);
807	img->move (cx, cy);	884	img->move (cx, cy);
808		885
809	return img;	886	return img;
810	}	887	}
…		…
813	rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)	890	rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
814	{	891	{
815	if (new_format == format)	892	if (new_format == format)
816	return clone ();	893	return clone ();
817		894
818	rxvt_img *img = new rxvt_img (s, new_format, x, y, w, h, repeat);	895	composer cc (this, new rxvt_img (d, new_format, x, y, w, h, repeat));
819	img->alloc ();
820		896
821	Display *dpy = s->display->dpy;
822	Picture src = picture ();
823	Picture dst = XRenderCreatePicture (dpy, img->pm, new_format, 0, 0);
824	int op = PictOpSrc;	897	int op = PictOpSrc;
825		898
826	if (format->direct.alphaMask && !new_format->direct.alphaMask)	899	if (format->direct.alphaMask && !new_format->direct.alphaMask)
827	{	900	{
828	// does it have to be that complicated	901	// does it have to be that complicated
829	XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };	902	XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
830	XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);	903	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
831		904
832	op = PictOpOver;	905	op = PictOpOver;
833	}	906	}
834		907
835	XRenderComposite (dpy, op, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);	908	XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
836		909
837	XRenderFreePicture (dpy, src);	910	return cc;
838	XRenderFreePicture (dpy, dst);	911	}
		912
		913	rxvt_img *
		914	rxvt_img::tint (const rgba &c)
		915	{
		916	composer cc (this);
		917	cc.mask (true);
		918	cc.fill (c);
		919
		920	XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
		921
		922	return cc;
		923	}
		924
		925	rxvt_img *
		926	rxvt_img::shade (nv factor, rgba c)
		927	{
		928	clamp_it (factor, -1., 1.);
		929	factor++;
		930
		931	if (factor > 1)
		932	{
		933	c.r = c.r * (2 - factor);
		934	c.g = c.g * (2 - factor);
		935	c.b = c.b * (2 - factor);
		936	}
		937	else
		938	{
		939	c.r = c.r * factor;
		940	c.g = c.g * factor;
		941	c.b = c.b * factor;
		942	}
		943
		944	rxvt_img *img = this->tint (c);
		945
		946	if (factor > 1)
		947	{
		948	c.a = 0xffff;
		949	c.r =
		950	c.g =
		951	c.b = 0xffff * (factor - 1);
		952
		953	img->brightness (c.r, c.g, c.b, c.a);
		954	}
839		955
840	return img;	956	return img;
841	}	957	}
842		958
843	rxvt_img *	959	rxvt_img *
844	rxvt_img::blend (rxvt_img *img, nv factor)	960	rxvt_img::filter (const char name, int nparams, nv params)
845	{	961	{
846	rxvt_img *img2 = clone ();	962	composer cc (this);
847	Display *dpy = s->display->dpy;
848	Picture src = img->picture ();
849	Picture dst = XRenderCreatePicture (dpy, img2->pm, img2->format, 0, 0);
850	Picture mask = create_xrender_mask (dpy, img->pm, False, False);
851		963
852	XRenderColor mask_c;	964	XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
853		965
854	mask_c.alpha = float_to_component (factor);	966	for (int i = 0; i < nparams; ++i)
855	mask_c.red =	967	xparams [i] = XDoubleToFixed (params [i]);
856	mask_c.green =
857	mask_c.blue = 0;
858	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
859		968
		969	XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
		970
860	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, w, h);	971	XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
861		972
862	XRenderFreePicture (dpy, src);
863	XRenderFreePicture (dpy, dst);
864	XRenderFreePicture (dpy, mask);
865
866	return img2;	973	return cc;
867	}	974	}
868		975
869	#endif	976	#endif
870		977

Diff Legend

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

Comparing rxvt-unicode/src/rxvtimg.C (file contents): Revision 1.93 by root, Fri Jun 15 18:07:24 2012 UTC vs. Revision 1.109 by sf-exg, Sat Jul 15 08:16:31 2017 UTC

Diff Legend

Comparing rxvt-unicode/src/rxvtimg.C (file contents):
Revision 1.93 by root, Fri Jun 15 18:07:24 2012 UTC vs.
Revision 1.109 by sf-exg, Sat Jul 15 08:16:31 2017 UTC