ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/rxvtimg.C
(Generate patch)

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

Diff Legend

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