[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.108 by sf-exg, Fri Nov 7 13:45:55 2014 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->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	// 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)
…		…
167	}	261	}
168		262
169	rxvt_img *	263	rxvt_img *
170	rxvt_img::new_from_root (rxvt_screen *s)	264	rxvt_img::new_from_root (rxvt_screen *s)
171	{	265	{
172	Display *dpy = s->display->dpy;	266	Display *dpy = s->dpy;
173	unsigned int root_pm_w, root_pm_h;	267	unsigned int root_pm_w, root_pm_h;
174	Pixmap root_pixmap = s->display->get_pixmap_property (s->display->xa[XA_XROOTPMAP_ID]);	268	Pixmap root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_XROOTPMAP_ID]);
175	if (root_pixmap == None)	269	if (root_pixmap == None)
176	root_pixmap = s->display->get_pixmap_property (s->display->xa[XA_ESETROOT_PMAP_ID]);	270	root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_ESETROOT_PMAP_ID]);
177		271
178	if (root_pixmap == None)	272	if (root_pixmap == None)
179	return 0;	273	return 0;
180		274
181	Window wdummy;	275	Window wdummy;
…		…
204	# if HAVE_PIXBUF	298	# if HAVE_PIXBUF
205		299
206	rxvt_img *	300	rxvt_img *
207	rxvt_img::new_from_pixbuf (rxvt_screen s, GdkPixbuf pb)	301	rxvt_img::new_from_pixbuf (rxvt_screen s, GdkPixbuf pb)
208	{	302	{
209	Display *dpy = s->display->dpy;	303	Display *dpy = s->dpy;
210		304
211	int width = gdk_pixbuf_get_width (pb);	305	int width = gdk_pixbuf_get_width (pb);
212	int height = gdk_pixbuf_get_height (pb);	306	int height = gdk_pixbuf_get_height (pb);
213		307
214	if (width > 32767 \|\| height > 32767) // well, we could upload in chunks	308	if (width > 32767 \|\| height > 32767) // well, we could upload in chunks
…		…
256	for (int y = 0; y < height; y++)	350	for (int y = 0; y < height; y++)
257	{	351	{
258	unsigned char *src = row;	352	unsigned char *src = row;
259	uint32_t dst = (uint32_t )line;	353	uint32_t dst = (uint32_t )line;
260		354
261	if (!pb_has_alpha)
262	for (int x = 0; x < width; x++)	355	for (int x = 0; x < width; x++)
263	{	356	{
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++;
		360	uint8_t a = *src;
267		361
		362	// this is done so it can be jump-free, but newer gcc's clone inner the loop
		363	a = pb_has_alpha ? a : 255;
		364	src += pb_has_alpha;
		365
		366	r = (r * a + 127) / 255;
		367	g = (g * a + 127) / 255;
		368	b = (b * a + 127) / 255;
		369
268	uint32_t v = (255 << 24) \| (r << 16) \| (g << 8) \| b;	370	uint32_t v = (a << 24) \| (r << 16) \| (g << 8) \| b;
269		371
270	if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch)	372	if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch)
271	v = ecb_bswap32 (v);	373	v = ecb_bswap32 (v);
272		374
273	*dst++ = v;	375	*dst++ = v;
274	}	376	}
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		377
291	row += rowstride;	378	row += rowstride;
292	line += xi.bytes_per_line;	379	line += xi.bytes_per_line;
293	}	380	}
294		381
…		…
327	{	414	{
328	if (--ref->cnt)	415	if (--ref->cnt)
329	return;	416	return;
330		417
331	if (pm && ref->ours)	418	if (pm && ref->ours)
332	XFreePixmap (s->display->dpy, pm);	419	XFreePixmap (s->dpy, pm);
333		420
334	delete ref;	421	delete ref;
335	}	422	}
336		423
337	rxvt_img::~rxvt_img ()	424	rxvt_img::~rxvt_img ()
…		…
340	}	427	}
341		428
342	void	429	void
343	rxvt_img::alloc ()	430	rxvt_img::alloc ()
344	{	431	{
345	pm = XCreatePixmap (s->display->dpy, s->display->root, w, h, format->depth);	432	pm = XCreatePixmap (s->dpy, s->display->root, w, h, format->depth);
346	ref = new pixref (w, h);	433	ref = new pixref (w, h);
		434	}
		435
		436	rxvt_img *
		437	rxvt_img::new_empty ()
		438	{
		439	rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat);
		440	img->alloc ();
		441
		442	return img;
347	}	443	}
348		444
349	Picture	445	Picture
350	rxvt_img::picture ()	446	rxvt_img::picture ()
351	{	447	{
352	Display *dpy = s->display->dpy;	448	Display *dpy = s->dpy;
353		449
354	XRenderPictureAttributes pa;	450	XRenderPictureAttributes pa;
355	pa.repeat = repeat;	451	pa.repeat = repeat;
356	Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);	452	Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
357		453
…		…
362	rxvt_img::unshare ()	458	rxvt_img::unshare ()
363	{	459	{
364	if (ref->cnt == 1 && ref->ours)	460	if (ref->cnt == 1 && ref->ours)
365	return;	461	return;
366		462
367	Pixmap pm2 = XCreatePixmap (s->display->dpy, s->display->root, ref->w, ref->h, format->depth);	463	Pixmap pm2 = XCreatePixmap (s->dpy, s->display->root, ref->w, ref->h, format->depth);
368	GC gc = XCreateGC (s->display->dpy, pm, 0, 0);	464	GC gc = XCreateGC (s->dpy, pm, 0, 0);
369	XCopyArea (s->display->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);	465	XCopyArea (s->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);
370	XFreeGC (s->display->dpy, gc);	466	XFreeGC (s->dpy, gc);
371		467
372	destroy ();	468	destroy ();
373		469
374	pm = pm2;	470	pm = pm2;
375	ref = new pixref (ref->w, ref->h);	471	ref = new pixref (ref->w, ref->h);
376	}	472	}
377		473
378	void	474	void
		475	rxvt_img::fill (const rgba &c, int x, int y, int w, int h)
		476	{
		477	XRenderColor rc = { c.r, c.g, c.b, c.a };
		478
		479	Display *dpy = s->dpy;
		480	Picture src = picture ();
		481	XRenderFillRectangle (dpy, PictOpSrc, src, &rc, x, y, w, h);
		482	XRenderFreePicture (dpy, src);
		483	}
		484
		485	void
379	rxvt_img::fill (const rgba &c)	486	rxvt_img::fill (const rgba &c)
380	{	487	{
381	XRenderColor rc = { c.r, c.g, c.b, c.a };	488	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	}	489	}
388		490
389	void	491	void
390	rxvt_img::add_alpha ()	492	rxvt_img::add_alpha ()
391	{	493	{
392	if (format->direct.alphaMask)	494	if (format->direct.alphaMask)
393	return;	495	return;
394		496
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);	497	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		498
403	XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);	499	XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
404		500
405	XRenderFreePicture (dpy, src);	501	rxvt_img *img = cc;
406	XRenderFreePicture (dpy, dst);
407		502
408	::swap (img->ref, ref);	503	::swap (img->ref, ref);
409	::swap (img->pm , pm );	504	::swap (img->pm , pm );
410		505
411	delete img;	506	delete img;
…		…
436	rxvt_img::blur (int rh, int rv)	531	rxvt_img::blur (int rh, int rv)
437	{	532	{
438	if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))	533	if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))
439	return clone ();	534	return clone ();
440		535
441	Display *dpy = s->display->dpy;	536	Display *dpy = s->dpy;
442	int size = max (rh, rv) * 2 + 1;	537	int size = max (rh, rv) * 2 + 1;
443	nv kernel = (nv )malloc (size * sizeof (nv));	538	nv kernel = (nv )malloc (size * sizeof (nv));
444	XFixed params = (XFixed )malloc ((size + 2) * sizeof (XFixed));	539	XFixed *params = rxvt_temp_buf<XFixed> (size + 2);
445	rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat);	540	rxvt_img *img = new_empty ();
446	img->alloc ();
447		541
448	XRenderPictureAttributes pa;	542	XRenderPictureAttributes pa;
449	pa.repeat = RepeatPad;	543	pa.repeat = RepeatPad;
450	Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);	544	Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
451	Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);	545	Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
…		…
485	0, 0,	579	0, 0,
486	w, h);	580	w, h);
487	}	581	}
488		582
489	free (kernel);	583	free (kernel);
490	free (params);
491		584
492	XRenderFreePicture (dpy, src);	585	XRenderFreePicture (dpy, src);
493	XRenderFreePicture (dpy, dst);	586	XRenderFreePicture (dpy, dst);
494	XRenderFreePicture (dpy, tmp);	587	XRenderFreePicture (dpy, tmp);
495		588
496	return img;	589	return img;
497	}	590	}
498		591
499	static Picture	592	rxvt_img *
500	create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)	593	rxvt_img::muladd (nv mul, nv add)
501	{	594	{
502	Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);	595	// STEP 1: double the image width, fill all odd columns with white (==1)
503		596
504	XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);	597	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		598
510	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	};
511		606
512	return mask;	607	XRenderSetPictureFilter (cc.dpy, cc.src, "nearest", 0, 0);
513	}	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);
514		610
515	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
516	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)
517	{	652	{
518	int32_t x = clamp (c, cl0, cl1);	653	int32_t x = clamp (c, cl0, cl1);
519	c -= x;	654	c -= x;
520	xc = x;	655	xc = x;
521	}	656	}
522		657
523	static bool	658	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)	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)
525	{	660	{
526	extract (cl0, cl1, r, xr);	661	extract (cl0, cl1, r, xr);
527	extract (cl0, cl1, g, xg);	662	extract (cl0, cl1, g, xg);
528	extract (cl0, cl1, b, xb);	663	extract (cl0, cl1, b, xb);
…		…
534	void	669	void
535	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)
536	{	671	{
537	unshare ();	672	unshare ();
538		673
539	Display *dpy = s->display->dpy;	674	Display *dpy = s->dpy;
540	Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);	675	Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
541		676
542	// 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
543	//while (r \| g \| b \| a)	678	//while (r \| g \| b \| a)
544	{	679	{
…		…
568	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)
569	{	704	{
570	if (r < 0 \|\| g < 0 \|\| b < 0 \|\| a < 0)	705	if (r < 0 \|\| g < 0 \|\| b < 0 \|\| a < 0)
571	rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");	706	rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
572		707
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)	708	// premultiply (yeah, these are not exact, sue me or fix it)
578	r = (r * (a >> 8)) >> 8;	709	r = (r * (a >> 8)) >> 8;
579	g = (g * (a >> 8)) >> 8;	710	g = (g * (a >> 8)) >> 8;
580	b = (b * (a >> 8)) >> 8;	711	b = (b * (a >> 8)) >> 8;
581		712
582	Display *dpy = s->display->dpy;	713	composer cc (this);
		714	rxvt_img *img = cc;
		715	img->fill (rgba (0, 0, 0, 0));
583		716
584	Picture src = picture ();	717	cc.mask (true);
585	Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
586	Picture mul = create_xrender_mask (dpy, pm, True, True);
587		718
588	//TODO: this operator does not yet implement some useful contrast	719	//TODO: this operator does not yet implement some useful contrast
589	while (r \| g \| b \| a)	720	while (r \| g \| b \| a)
590	{	721	{
591	unsigned short xr, xg, xb, xa;	722	unsigned short xr, xg, xb, xa;
592	XRenderColor mask_c;	723	XRenderColor mask_c;
593		724
594	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))
595	{	726	{
596	XRenderFillRectangle (dpy, PictOpSrc, mul, &mask_c, 0, 0, 1, 1);	727	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);	728	XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
598	}	729	}
599	}	730	}
600
601	XRenderFreePicture (dpy, mul);
602	XRenderFreePicture (dpy, dst);
603	XRenderFreePicture (dpy, src);
604		731
605	::swap (img->ref, ref);	732	::swap (img->ref, ref);
606	::swap (img->pm , pm );	733	::swap (img->pm , pm );
607		734
608	delete img;	735	delete img;
…		…
611	void	738	void
612	rxvt_img::draw (rxvt_img *img, int op, nv mask)	739	rxvt_img::draw (rxvt_img *img, int op, nv mask)
613	{	740	{
614	unshare ();	741	unshare ();
615		742
616	Display *dpy = s->display->dpy;	743	composer cc (img, this);
617	Picture src = img->picture ();
618	Picture dst = picture ();
619	Picture mask_p = 0;
620		744
621	if (mask != 1.)	745	if (mask != 1.)
622	{	746	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		747
628	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);
629
630	XRenderFreePicture (dpy, src);
631	XRenderFreePicture (dpy, dst);
632
633	if (mask_p)
634	XRenderFreePicture (dpy, mask_p);
635	}	749	}
636		750
637	rxvt_img *	751	rxvt_img *
638	rxvt_img::clone ()	752	rxvt_img::clone ()
639	{	753	{
…		…
643	rxvt_img *	757	rxvt_img *
644	rxvt_img::reify ()	758	rxvt_img::reify ()
645	{	759	{
646	if (x == 0 && y == 0 && w == ref->w && h == ref->h)	760	if (x == 0 && y == 0 && w == ref->w && h == ref->h)
647	return clone ();	761	return clone ();
648
649	Display *dpy = s->display->dpy;
650		762
651	// add an alpha channel if...	763	// add an alpha channel if...
652	bool alpha = !format->direct.alphaMask // pixmap has none yet	764	bool alpha = !format->direct.alphaMask // pixmap has none yet
653	&& (x \|\| y) // we need one because of non-zero offset	765	&& (x \|\| y) // we need one because of non-zero offset
654	&& repeat == RepeatNone; // and we have no good pixels to fill with	766	&& repeat == RepeatNone; // and we have no good pixels to fill with
655		767
656	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,
657	img->alloc ();	769	0, 0, w, h, repeat));
658		770
659	Picture src = picture ();	771	if (repeat == RepeatNone)
660	Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
661
662	if (alpha)
663	{	772	{
664	XRenderColor rc = { 0, 0, 0, 0 };	773	XRenderColor rc = { 0, 0, 0, 0 };
665	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
666	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);
667	}	776	}
668	else	777	else
669	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);
670		779
671	XRenderFreePicture (dpy, src);
672	XRenderFreePicture (dpy, dst);
673
674	return img;	780	return cc;
675	}	781	}
676		782
677	rxvt_img *	783	rxvt_img *
678	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)
679	{	785	{
…		…
694		800
695	return img;	801	return img;
696	}	802	}
697		803
698	rxvt_img *	804	rxvt_img *
699	rxvt_img::transform (nv matrix[3][3])	805	rxvt_img::transform (const nv matrix[3][3])
700	{	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
701	// calculate new pixel bounding box coordinates	815	// calculate new pixel bounding box coordinates
702	nv r[2], rmin[2], rmax[2];	816	nv rmin[2], rmax[2];
703
704	mat3x3 m (matrix);
705		817
706	for (int i = 0; i < 2; ++i)	818	for (int i = 0; i < 2; ++i)
707	{	819	{
708	nv v;	820	nv v;
709		821
710	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;
711	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);
712	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);
713	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);
714	}	826	}
715		827
…		…
721	int ny = floor (rmin [1]);	833	int ny = floor (rmin [1]);
722		834
723	int new_width = ceil (rmax [0] - rmin [0]);	835	int new_width = ceil (rmax [0] - rmin [0]);
724	int new_height = ceil (rmax [1] - rmin [1]);	836	int new_height = ceil (rmax [1] - rmin [1]);
725		837
726	m = mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y);	838	mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
727		839
728	mat3x3 inv = m.invert ();	840	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		841
737	XTransform xfrm;	842	XTransform xfrm;
738		843
739	for (int i = 0; i < 3; ++i)	844	for (int i = 0; i < 3; ++i)
740	for (int j = 0; j < 3; ++j)	845	for (int j = 0; j < 3; ++j)
741	xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);	846	xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
742		847
743	XRenderSetPictureFilter (dpy, src, "good", 0, 0);	848	XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
744	XRenderSetPictureTransform (dpy, src, &xfrm);	849	XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
745	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);
746		851
747	XRenderFreePicture (dpy, src);
748	XRenderFreePicture (dpy, dst);
749
750	return img;	852	return cc;
751	}	853	}
752		854
753	rxvt_img *	855	rxvt_img *
754	rxvt_img::scale (int new_width, int new_height)	856	rxvt_img::scale (int new_width, int new_height)
755	{	857	{
756	if (w == new_width && h == new_height)	858	if (w == new_width && h == new_height)
757	return clone ();	859	return clone ();
758		860
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;	861	int old_repeat_mode = repeat;
766	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
767		863
768	rxvt_img *img = transform (matrix);	864	rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
769		865
770	repeat = old_repeat_mode;	866	repeat = old_repeat_mode;
771	img->repeat = repeat;	867	img->repeat = repeat;
772		868
773	return img;	869	return img;
774	}	870	}
775		871
776	rxvt_img *	872	rxvt_img *
777	rxvt_img::rotate (int cx, int cy, nv phi)	873	rxvt_img::rotate (int cx, int cy, nv phi)
778	{	874	{
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);	875	move (-cx, -cy);
795	rxvt_img *img = transform (matrix);	876	rxvt_img *img = transform (mat3x3::rotate (phi));
796	move ( cx, cy);	877	move ( cx, cy);
797	img->move (cx, cy);	878	img->move (cx, cy);
798		879
799	return img;	880	return img;
800	}	881	}
…		…
803	rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)	884	rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
804	{	885	{
805	if (new_format == format)	886	if (new_format == format)
806	return clone ();	887	return clone ();
807		888
808	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));
809	img->alloc ();
810		890
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;	891	int op = PictOpSrc;
815		892
816	if (format->direct.alphaMask && !new_format->direct.alphaMask)	893	if (format->direct.alphaMask && !new_format->direct.alphaMask)
817	{	894	{
818	// does it have to be that complicated	895	// does it have to be that complicated
819	XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };	896	XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
820	XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);	897	XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
821		898
822	op = PictOpOver;	899	op = PictOpOver;
823	}	900	}
824		901
825	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);
826		903
827	XRenderFreePicture (dpy, src);	904	return cc;
828	XRenderFreePicture (dpy, dst);	905	}
		906
		907	rxvt_img *
		908	rxvt_img::tint (const rgba &c)
		909	{
		910	composer cc (this);
		911	cc.mask (true);
		912	cc.fill (c);
		913
		914	XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
		915
		916	return cc;
		917	}
		918
		919	rxvt_img *
		920	rxvt_img::shade (nv factor, rgba c)
		921	{
		922	clamp_it (factor, -1., 1.);
		923	factor++;
		924
		925	if (factor > 1)
		926	{
		927	c.r = c.r * (2 - factor);
		928	c.g = c.g * (2 - factor);
		929	c.b = c.b * (2 - factor);
		930	}
		931	else
		932	{
		933	c.r = c.r * factor;
		934	c.g = c.g * factor;
		935	c.b = c.b * factor;
		936	}
		937
		938	rxvt_img *img = this->tint (c);
		939
		940	if (factor > 1)
		941	{
		942	c.a = 0xffff;
		943	c.r =
		944	c.g =
		945	c.b = 0xffff * (factor - 1);
		946
		947	img->brightness (c.r, c.g, c.b, c.a);
		948	}
829		949
830	return img;	950	return img;
831	}	951	}
832		952
833	rxvt_img *	953	rxvt_img *
834	rxvt_img::blend (rxvt_img *img, nv factor)	954	rxvt_img::filter (const char name, int nparams, nv params)
835	{	955	{
836	rxvt_img *img2 = clone ();	956	composer cc (this);
837	Display *dpy = s->display->dpy;
838	Picture src = img->picture ();
839	Picture dst = XRenderCreatePicture (dpy, img2->pm, img2->format, 0, 0);
840	Picture mask = create_xrender_mask (dpy, img->pm, False, False);
841		957
842	XRenderColor mask_c;	958	XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
843		959
844	mask_c.alpha = float_to_component (factor);	960	for (int i = 0; i < nparams; ++i)
845	mask_c.red =	961	xparams [i] = XDoubleToFixed (params [i]);
846	mask_c.green =
847	mask_c.blue = 0;
848	XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
849		962
		963	XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
		964
850	XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, w, h);	965	XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
851		966
852	XRenderFreePicture (dpy, src);
853	XRenderFreePicture (dpy, dst);
854	XRenderFreePicture (dpy, mask);
855
856	return img2;	967	return cc;
857	}	968	}
858		969
859	#endif	970	#endif
860		971

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.108 by sf-exg, Fri Nov 7 13:45:55 2014 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.108 by sf-exg, Fri Nov 7 13:45:55 2014 UTC