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.18 by sf-exg, Tue Jun 5 12:30:37 2012 UTC vs.
Revision 1.107 by root, Thu May 22 18:54:33 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 XRenderColor rc = {
194 c.r * c.a / 65535,
195 c.g * c.a / 65535,
196 c.b * c.a / 65535,
197 c.a
198 };
199 msk = XRenderCreateSolidFill (dpy, &rc);
200 ecb_assume (msk);
201 }
202
203 void fill (const rgba &c)
204 {
205 XRenderColor rc = {
206 c.r * c.a / 65535,
207 c.g * c.a / 65535,
208 c.b * c.a / 65535,
209 c.a
210 };
211
212 XRenderFillRectangle (dpy, PictOpSrc, msk, &rc, 0, 0, 1, 1);
213 }
214
215 operator rxvt_img *()
216 {
217 return dstimg;
218 }
219
220 ecb_noinline
221 ~composer ()
222 {
223 XRenderFreePicture (dpy, src);
224 XRenderFreePicture (dpy, dst);
225 if (msk) XRenderFreePicture (dpy, msk);
226 }
227 };
228}
229
230static XRenderPictFormat *
231find_alpha_format_for (Display *dpy, XRenderPictFormat *format)
232{
233 if (format->direct.alphaMask)
234 return format; // already has alpha
235
236 // try to find a suitable alpha format, one bit alpha is enough for our purposes
237 if (format->type == PictTypeDirect)
238 for (int n = 0; XRenderPictFormat *f = XRenderFindFormat (dpy, 0, 0, n); ++n)
239 if (f->direct.alphaMask
240 && f->type == PictTypeDirect
241 && ecb_popcount32 (f->direct.redMask ) >= ecb_popcount32 (format->direct.redMask )
242 && ecb_popcount32 (f->direct.greenMask) >= ecb_popcount32 (format->direct.greenMask)
243 && ecb_popcount32 (f->direct.blueMask ) >= ecb_popcount32 (format->direct.blueMask ))
244 return f;
245
246 // should be a very good fallback
247 return XRenderFindStandardFormat (dpy, PictStandardARGB32);
248}
249
9rxvt_img::rxvt_img (rxvt_screen *screen, XRenderPictFormat *format, int width, int height) 250rxvt_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) 251: s(screen), x(x), y(y), w(width), h(height), format(format), repeat(repeat),
252 pm(0), ref(0)
17{ 253{
254}
255
256rxvt_img::rxvt_img (const rxvt_img &img)
257: 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)
258{
259 ++ref->cnt;
260}
261
262rxvt_img *
263rxvt_img::new_from_root (rxvt_screen *s)
264{
265 Display *dpy = s->dpy;
266 unsigned int root_pm_w, root_pm_h;
267 Pixmap root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_XROOTPMAP_ID]);
268 if (root_pixmap == None)
269 root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_ESETROOT_PMAP_ID]);
270
271 if (root_pixmap == None)
272 return 0;
273
274 Window wdummy;
275 int idummy;
276 unsigned int udummy;
277
278 if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pm_w, &root_pm_h, &udummy, &udummy))
279 return 0;
280
281 rxvt_img *img = new rxvt_img (
282 s,
283 XRenderFindVisualFormat (dpy, DefaultVisual (dpy, s->display->screen)),
284 0,
285 0,
286 root_pm_w,
287 root_pm_h
288 );
289
290 img->pm = root_pixmap;
291 img->ref = new pixref (root_pm_w, root_pm_h);
292 img->ref->ours = false;
293
294 return img;
295}
296
297# if HAVE_PIXBUF
298
299rxvt_img *
300rxvt_img::new_from_pixbuf (rxvt_screen *s, GdkPixbuf *pb)
301{
302 Display *dpy = s->dpy;
303
304 int width = gdk_pixbuf_get_width (pb);
305 int height = gdk_pixbuf_get_height (pb);
306
307 if (width > 32767 || height > 32767) // well, we *could* upload in chunks
308 rxvt_fatal ("rxvt_img::new_from_pixbuf: image too big (maximum size 32768x32768).\n");
309
310 // since we require rgb24/argb32 formats from xrender we assume
311 // that both 24 and 32 bpp MUST be supported by any screen that supports xrender
312
313 int byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
314
315 XImage xi;
316
317 xi.width = width;
318 xi.height = height;
319 xi.xoffset = 0;
320 xi.format = ZPixmap;
321 xi.byte_order = ImageByteOrder (dpy);
322 xi.bitmap_unit = 0; //XY only, unused
323 xi.bitmap_bit_order = 0; //XY only, unused
324 xi.bitmap_pad = BitmapPad (dpy);
325 xi.depth = 32;
326 xi.bytes_per_line = 0;
327 xi.bits_per_pixel = 32; //Z only
328 xi.red_mask = 0x00000000; //Z only, unused
329 xi.green_mask = 0x00000000; //Z only, unused
330 xi.blue_mask = 0x00000000; //Z only, unused
331 xi.obdata = 0; // probably unused
332
333 bool byte_order_mismatch = byte_order != xi.byte_order;
334
335 if (!XInitImage (&xi))
336 rxvt_fatal ("unable to initialise ximage, please report.\n");
337
338 if (height > INT_MAX / xi.bytes_per_line)
339 rxvt_fatal ("rxvt_img::new_from_pixbuf: image too big for Xlib.\n");
340
341 xi.data = (char *)rxvt_malloc (height * xi.bytes_per_line);
342
343 int rowstride = gdk_pixbuf_get_rowstride (pb);
344 bool pb_has_alpha = gdk_pixbuf_get_has_alpha (pb);
345 unsigned char *row = gdk_pixbuf_get_pixels (pb);
346
347 char *line = xi.data;
348
349 for (int y = 0; y < height; y++)
350 {
351 unsigned char *src = row;
352 uint32_t *dst = (uint32_t *)line;
353
354 for (int x = 0; x < width; x++)
355 {
356 uint8_t r = *src++;
357 uint8_t g = *src++;
358 uint8_t b = *src++;
359 uint8_t a = *src;
360
361 // this is done so it can be jump-free, but newer gcc's clone inner the loop
362 a = pb_has_alpha ? a : 255;
363 src += pb_has_alpha;
364
365 r = (r * a + 127) / 255;
366 g = (g * a + 127) / 255;
367 b = (b * a + 127) / 255;
368
369 uint32_t v = (a << 24) | (r << 16) | (g << 8) | b;
370
371 if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch)
372 v = ecb_bswap32 (v);
373
374 *dst++ = v;
375 }
376
377 row += rowstride;
378 line += xi.bytes_per_line;
379 }
380
381 rxvt_img *img = new rxvt_img (s, XRenderFindStandardFormat (dpy, PictStandardARGB32), 0, 0, width, height);
382 img->alloc ();
383
384 GC gc = XCreateGC (dpy, img->pm, 0, 0);
385 XPutImage (dpy, img->pm, gc, &xi, 0, 0, 0, 0, width, height);
386 XFreeGC (dpy, gc);
387
388 free (xi.data);
389
390 return img;
18} 391}
19 392
20rxvt_img * 393rxvt_img *
21rxvt_img::new_from_file (rxvt_screen *s, const char *filename) 394rxvt_img::new_from_file (rxvt_screen *s, const char *filename)
22{ 395{
… …
24 GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err); 397 GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err);
25 398
26 if (!pb) 399 if (!pb)
27 rxvt_fatal ("rxvt_img::new_from_file: %s\n", err->message); 400 rxvt_fatal ("rxvt_img::new_from_file: %s\n", err->message);
28 401
29 rxvt_img *img = new rxvt_img ( 402 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 403
36 img->render_pixbuf (pb, 0, 0, img->w, img->h, 0, 0); 404 g_object_unref (pb);
37 405
38 return img; 406 return img;
39} 407}
40 408
409# endif
410
411void
412rxvt_img::destroy ()
413{
414 if (--ref->cnt)
415 return;
416
417 if (pm && ref->ours)
418 XFreePixmap (s->dpy, pm);
419
420 delete ref;
421}
422
41rxvt_img::~rxvt_img () 423rxvt_img::~rxvt_img ()
42{ 424{
43 if (!shared) 425 destroy ();
44 XFreePixmap (s->display->dpy, pm); 426}
427
428void
429rxvt_img::alloc ()
430{
431 pm = XCreatePixmap (s->dpy, s->display->root, w, h, format->depth);
432 ref = new pixref (w, h);
433}
434
435rxvt_img *
436rxvt_img::new_empty ()
437{
438 rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat);
439 img->alloc ();
440
441 return img;
442}
443
444Picture
445rxvt_img::picture ()
446{
447 Display *dpy = s->dpy;
448
449 XRenderPictureAttributes pa;
450 pa.repeat = repeat;
451 Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
452
453 return pic;
45} 454}
46 455
47void 456void
48rxvt_img::unshare () 457rxvt_img::unshare ()
49{ 458{
50 if (!shared) 459 if (ref->cnt == 1 && ref->ours)
51 return; 460 return;
52 461
462 Pixmap pm2 = XCreatePixmap (s->dpy, s->display->root, ref->w, ref->h, format->depth);
463 GC gc = XCreateGC (s->dpy, pm, 0, 0);
464 XCopyArea (s->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);
465 XFreeGC (s->dpy, gc);
466
467 destroy ();
468
469 pm = pm2;
470 ref = new pixref (ref->w, ref->h);
471}
472
473void
474rxvt_img::fill (const rgba &c, int x, int y, int w, int h)
475{
476 XRenderColor rc = { c.r, c.g, c.b, c.a };
477
478 Display *dpy = s->dpy;
479 Picture src = picture ();
480 XRenderFillRectangle (dpy, PictOpSrc, src, &rc, x, y, w, h);
481 XRenderFreePicture (dpy, src);
482}
483
484void
485rxvt_img::fill (const rgba &c)
486{
487 fill (c, 0, 0, w, h);
488}
489
490void
491rxvt_img::add_alpha ()
492{
493 if (format->direct.alphaMask)
494 return;
495
496 composer cc (this, new rxvt_img (s, find_alpha_format_for (s->dpy, format), x, y, w, h, repeat));
497
498 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
499
53 rxvt_img *img = clone (); 500 rxvt_img *img = cc;
54 501
55 ::swap (pm , img->pm); 502 ::swap (img->ref, ref);
56 ::swap (shared, img->shared); 503 ::swap (img->pm , pm );
57 504
58 delete img; 505 delete img;
59} 506}
60 507
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 508static void
72get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params) 509get_gaussian_kernel (int radius, int width, nv *kernel, XFixed *params)
73{ 510{
74 double sigma = radius / 2.0; 511 nv sigma = radius / 2.0;
75 double scale = sqrt (2.0 * M_PI) * sigma; 512 nv scale = sqrt (2.0 * M_PI) * sigma;
76 double sum = 0.0; 513 nv sum = 0.0;
77 514
78 for (int i = 0; i < width; i++) 515 for (int i = 0; i < width; i++)
79 { 516 {
80 double x = i - width / 2; 517 nv x = i - width / 2;
81 kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale; 518 kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;
82 sum += kernel[i]; 519 sum += kernel[i];
83 } 520 }
84 521
85 params[0] = XDoubleToFixed (width); 522 params[0] = XDoubleToFixed (width);
… …
87 524
88 for (int i = 0; i < width; i++) 525 for (int i = 0; i < width; i++)
89 params[i+2] = XDoubleToFixed (kernel[i] / sum); 526 params[i+2] = XDoubleToFixed (kernel[i] / sum);
90} 527}
91 528
92void 529rxvt_img *
93rxvt_img::blur (int rh, int rv) 530rxvt_img::blur (int rh, int rv)
94{ 531{
95 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV)) 532 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))
96 return; 533 return clone ();
97 534
98 Display *dpy = s->display->dpy; 535 Display *dpy = s->dpy;
99 int size = max (rh, rv) * 2 + 1; 536 int size = max (rh, rv) * 2 + 1;
100 double *kernel = (double *)malloc (size * sizeof (double)); 537 nv *kernel = (nv *)malloc (size * sizeof (nv));
101 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 538 XFixed *params = rxvt_temp_buf<XFixed> (size + 2);
539 rxvt_img *img = new_empty ();
102 540
103 XRenderPictureAttributes pa; 541 XRenderPictureAttributes pa;
104
105 pa.repeat = RepeatPad; 542 pa.repeat = RepeatPad;
106 Picture src = XRenderCreatePicture (dpy, pm , format, CPRepeat, &pa); 543 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
544 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
545
107 Pixmap tmp = XCreatePixmap (dpy, pm, w, h, format->depth); 546 Pixmap tmp_pm = XCreatePixmap (dpy, pm, w, h, format->depth);
108 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa); 547 Picture tmp = XRenderCreatePicture (dpy, tmp_pm , format, CPRepeat, &pa);
109 XFreePixmap (dpy, tmp); 548 XFreePixmap (dpy, tmp_pm);
110 549
111 if (kernel && params) 550 if (kernel && params)
112 { 551 {
113 size = rh * 2 + 1; 552 size = rh * 2 + 1;
114 get_gaussian_kernel (rh, size, kernel, params); 553 get_gaussian_kernel (rh, size, kernel, params);
115 554
116 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 555 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
117 XRenderComposite (dpy, 556 XRenderComposite (dpy,
118 PictOpSrc, 557 PictOpSrc,
119 src, 558 src,
559 None,
560 tmp,
561 0, 0,
562 0, 0,
563 0, 0,
564 w, h);
565
566 size = rv * 2 + 1;
567 get_gaussian_kernel (rv, size, kernel, params);
568 ::swap (params[0], params[1]);
569
570 XRenderSetPictureFilter (dpy, tmp, FilterConvolution, params, size+2);
571 XRenderComposite (dpy,
572 PictOpSrc,
573 tmp,
120 None, 574 None,
121 dst, 575 dst,
122 0, 0, 576 0, 0,
123 0, 0, 577 0, 0,
124 0, 0, 578 0, 0,
125 w, h); 579 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 } 580 }
144 581
145 free (kernel); 582 free (kernel);
146 free (params); 583
147 XRenderFreePicture (dpy, src); 584 XRenderFreePicture (dpy, src);
148 XRenderFreePicture (dpy, dst); 585 XRenderFreePicture (dpy, dst);
149} 586 XRenderFreePicture (dpy, tmp);
150 587
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; 588 return img;
589}
590
591rxvt_img *
592rxvt_img::muladd (nv mul, nv add)
593{
594 // STEP 1: double the image width, fill all odd columns with white (==1)
595
596 composer cc (this, new rxvt_img (s, format, 0, 0, w * 2, h, repeat));
597
598 // why the hell does XRenderSetPictureTransform want a writable matrix :(
599 // that keeps us from just static const'ing this matrix.
600 XTransform h_double = {
601 0x08000, 0, 0,
602 0, 0x10000, 0,
603 0, 0, 0x10000
604 };
605
606 XRenderSetPictureFilter (cc.dpy, cc.src, "nearest", 0, 0);
607 XRenderSetPictureTransform (cc.dpy, cc.src, &h_double);
608 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
609
610 cc.mask (false, 2, 1);
611
612 static const XRenderColor c0 = { 0, 0, 0, 0 };
613 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c0, 0, 0, 1, 1);
614 static const XRenderColor c1 = { 65535, 65535, 65535, 65535 };
615 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c1, 1, 0, 1, 1);
616
617 Picture white = XRenderCreateSolidFill (cc.dpy, &c1);
618
619 XRenderComposite (cc.dpy, PictOpOver, white, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
620
621 XRenderFreePicture (cc.dpy, white);
622
623 // STEP 2: convolve the image with a 3x1 filter
624 // a 2x1 filter would obviously suffice, but given the total lack of specification
625 // for xrender, I expect different xrender implementations to randomly diverge.
626 // we also halve the image, and hope for the best (again, for lack of specs).
627 composer cc2 (cc.dstimg);
628
629 XFixed kernel [] = {
630 XDoubleToFixed (3), XDoubleToFixed (1),
631 XDoubleToFixed (0), XDoubleToFixed (mul), XDoubleToFixed (add)
632 };
633
634 XTransform h_halve = {
635 0x20000, 0, 0,
636 0, 0x10000, 0,
637 0, 0, 0x10000
638 };
639
640 XRenderSetPictureFilter (cc.dpy, cc2.src, "nearest", 0, 0);
641 XRenderSetPictureTransform (cc.dpy, cc2.src, &h_halve);
642 XRenderSetPictureFilter (cc.dpy, cc2.src, FilterConvolution, kernel, ecb_array_length (kernel));
643
644 XRenderComposite (cc.dpy, PictOpSrc, cc2.src, None, cc2.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
645
646 return cc2;
647}
648
649ecb_noinline static void
650extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
651{
652 int32_t x = clamp (c, cl0, cl1);
653 c -= x;
654 xc = x;
655}
656
657ecb_noinline static bool
658extract (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{
660 extract (cl0, cl1, r, xr);
661 extract (cl0, cl1, g, xg);
662 extract (cl0, cl1, b, xb);
663 extract (cl0, cl1, a, xa);
664
665 return xr | xg | xb | xa;
164} 666}
165 667
166void 668void
167rxvt_img::brightness (double r, double g, double b, double a) 669rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
168{ 670{
671 unshare ();
672
169 Display *dpy = s->display->dpy; 673 Display *dpy = s->dpy;
170 Picture src = create_xrender_mask (dpy, pm, True);
171 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 674 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
172 675
676 // loop should not be needed for brightness, as only -1..1 makes sense
677 //while (r | g | b | a)
678 {
679 unsigned short xr, xg, xb, xa;
173 XRenderColor mask_c; 680 XRenderColor mask_c;
174 mask_c.red = float_to_component (r); 681
175 mask_c.green = float_to_component (g); 682 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); 683 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
179 684
180 XRenderComposite (dpy, PictOpAdd, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 685 if (extract (-65535, 0, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
686 {
687 XRenderColor mask_w = { 65535, 65535, 65535, 65535 };
688 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
689 mask_c.red = -mask_c.red; //TODO: verify that doing clamp, assign, and negation does the right thing
690 mask_c.green = -mask_c.green;
691 mask_c.blue = -mask_c.blue;
692 mask_c.alpha = -mask_c.alpha;
693 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
694 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
695 }
696 }
697
698 XRenderFreePicture (dpy, dst);
181} 699}
182 700
183void 701void
184rxvt_img::contrast (double r, double g, double b, double a) 702rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
185{ 703{
186 if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL)) 704 if (r < 0 || g < 0 || b < 0 || a < 0)
187 return; 705 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
188 706
189 Display *dpy = s->display->dpy; 707 // premultiply (yeah, these are not exact, sue me or fix it)
190 Picture src = create_xrender_mask (dpy, pm, True); 708 r = (r * (a >> 8)) >> 8;
191 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 709 g = (g * (a >> 8)) >> 8;
710 b = (b * (a >> 8)) >> 8;
192 711
712 composer cc (this);
713 rxvt_img *img = cc;
714 img->fill (rgba (0, 0, 0, 0));
715
716 cc.mask (true);
717
718 //TODO: this operator does not yet implement some useful contrast
719 while (r | g | b | a)
720 {
721 unsigned short xr, xg, xb, xa;
193 XRenderColor mask_c; 722 XRenderColor mask_c;
194 mask_c.red = float_to_component (r);
195 mask_c.green = float_to_component (g);
196 mask_c.blue = float_to_component (b);
197 mask_c.alpha = float_to_component (a);
198 XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1);
199 723
200 XRenderComposite (dpy, PictOpMultiply, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 724 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
201}
202
203bool
204rxvt_img::render_pixbuf (GdkPixbuf *pixbuf, int src_x, int src_y, int width, int height, int dst_x, int dst_y)
205{
206 Display *dpy = s->display->dpy;
207
208 if (s->visual->c_class != TrueColor)
209 return false;
210
211 uint32_t red_mask, green_mask, blue_mask, alpha_mask;
212
213 red_mask = (uint32_t)format->direct.redMask << format->direct.red;
214 green_mask = (uint32_t)format->direct.greenMask << format->direct.green;
215 blue_mask = (uint32_t)format->direct.blueMask << format->direct.blue;
216 alpha_mask = (uint32_t)format->direct.alphaMask << format->direct.alpha;
217
218 int width_r = ecb_popcount32 (red_mask);
219 int width_g = ecb_popcount32 (green_mask);
220 int width_b = ecb_popcount32 (blue_mask);
221 int width_a = ecb_popcount32 (alpha_mask);
222
223 if (width_r > 8 || width_g > 8 || width_b > 8 || width_a > 8)
224 return false;
225
226 int sh_r = ecb_ctz32 (red_mask);
227 int sh_g = ecb_ctz32 (green_mask);
228 int sh_b = ecb_ctz32 (blue_mask);
229 int sh_a = ecb_ctz32 (alpha_mask);
230
231 if (width > 32767 || height > 32767)
232 return false;
233
234 XImage *ximage = XCreateImage (dpy, s->visual, format->depth, ZPixmap, 0, 0,
235 width, height, 32, 0);
236 if (!ximage)
237 return false;
238
239 if (height > INT_MAX / ximage->bytes_per_line
240 || !(ximage->data = (char *)malloc (height * ximage->bytes_per_line)))
241 {
242 XDestroyImage (ximage);
243 return false;
244 }
245
246 GC gc = XCreateGC (dpy, pm, 0, 0);
247
248 ximage->byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
249
250 int rowstride = gdk_pixbuf_get_rowstride (pixbuf);
251 int channels = gdk_pixbuf_get_n_channels (pixbuf);
252 unsigned char *row = gdk_pixbuf_get_pixels (pixbuf) + src_y * rowstride + src_x * channels;
253 char *line = ximage->data;
254
255 rgba c (0, 0, 0);
256
257 if (channels == 4 && alpha_mask == 0)
258 {
259 //pix_colors[Color_bg].get (c);
260 //TODO
261 c.r = 0xffff; c.g = 0xc0c0; c.b = 0xcbcb;//D
262 c.r >>= 8;
263 c.g >>= 8;
264 c.b >>= 8;
265 }
266
267 for (int y = 0; y < height; y++)
268 {
269 for (int x = 0; x < width; x++)
270 { 725 {
271 unsigned char *pixel = row + x * channels; 726 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &mask_c, 0, 0, 1, 1);
272 uint32_t value; 727 XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
273 unsigned char r, g, b, a;
274
275 if (channels == 4)
276 {
277 a = pixel[3];
278 r = (pixel[0] * a + c.r * (0xff - a)) / 0xff;
279 g = (pixel[1] * a + c.g * (0xff - a)) / 0xff;
280 b = (pixel[2] * a + c.b * (0xff - a)) / 0xff;
281 }
282 else
283 {
284 a = 0xff;
285 r = pixel[0];
286 g = pixel[1];
287 b = pixel[2];
288 }
289
290 value = ((r >> (8 - width_r)) << sh_r)
291 | ((g >> (8 - width_g)) << sh_g)
292 | ((b >> (8 - width_b)) << sh_b)
293 | ((a >> (8 - width_a)) << sh_a);
294
295 if (ximage->bits_per_pixel == 32)
296 ((uint32_t *)line)[x] = value;
297 else
298 XPutPixel (ximage, x, y, value);
299 } 728 }
300
301 row += rowstride;
302 line += ximage->bytes_per_line;
303 } 729 }
304 730
305 XPutImage (dpy, pm, gc, ximage, 0, 0, dst_x, dst_y, width, height); 731 ::swap (img->ref, ref);
306 XDestroyImage (ximage); 732 ::swap (img->pm , pm );
307 XFreeGC (dpy, gc);
308 733
309 return true; 734 delete img;
735}
736
737void
738rxvt_img::draw (rxvt_img *img, int op, nv mask)
739{
740 unshare ();
741
742 composer cc (img, this);
743
744 if (mask != 1.)
745 cc.mask (rgba (0, 0, 0, float_to_component (mask)));
746
747 XRenderComposite (cc.dpy, op, cc.src, cc.msk, cc.dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h);
310} 748}
311 749
312rxvt_img * 750rxvt_img *
313rxvt_img::clone () 751rxvt_img::clone ()
314{ 752{
315 GC gc = XCreateGC (s->display->dpy, pm, 0, 0); 753 return new rxvt_img (*this);
316 Pixmap pm2 = XCreatePixmap (s->display->dpy, pm, w, h, format->depth);
317 XCopyArea (s->display->dpy, pm, pm2, gc, 0, 0, w, h, 0, 0);
318 XFreeGC (s->display->dpy, gc);
319 return new rxvt_img (s, format, w, h, pm2);
320} 754}
321 755
322rxvt_img * 756rxvt_img *
323rxvt_img::transform (int new_width, int new_height, int repeat, double matrix[9]) 757rxvt_img::reify ()
324{ 758{
325 rxvt_img *img = new rxvt_img (s, format, new_width, new_height); 759 if (x == 0 && y == 0 && w == ref->w && h == ref->h)
760 return clone ();
326 761
327 Display *dpy = s->display->dpy; 762 // add an alpha channel if...
328 XRenderPictureAttributes pa; 763 bool alpha = !format->direct.alphaMask // pixmap has none yet
329 pa.repeat = repeat; 764 && (x || y) // we need one because of non-zero offset
330 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 765 && repeat == RepeatNone; // and we have no good pixels to fill with
331 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0); 766
767 composer cc (this, new rxvt_img (s, alpha ? find_alpha_format_for (s->dpy, format) : format,
768 0, 0, w, h, repeat));
769
770 if (repeat == RepeatNone)
771 {
772 XRenderColor rc = { 0, 0, 0, 0 };
773 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
774 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
775 }
776 else
777 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
778
779 return cc;
780}
781
782rxvt_img *
783rxvt_img::sub_rect (int x, int y, int width, int height)
784{
785 rxvt_img *img = clone ();
786
787 img->x -= x;
788 img->y -= y;
789
790 if (w != width || h != height)
791 {
792 img->w = width;
793 img->h = height;
794
795 rxvt_img *img2 = img->reify ();
796 delete img;
797 img = img2;
798 }
799
800 return img;
801}
802
803rxvt_img *
804rxvt_img::transform (const nv matrix[3][3])
805{
806 return transform (mat3x3 (&matrix[0][0]));
807}
808
809rxvt_img *
810rxvt_img::transform (const nv *matrix)
811{
812 mat3x3 m (matrix);
813
814 // calculate new pixel bounding box coordinates
815 nv rmin[2], rmax[2];
816
817 for (int i = 0; i < 2; ++i)
818 {
819 nv v;
820
821 v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v;
822 v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v);
823 v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
824 v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
825 }
826
827 float sx = rmin [0] - x;
828 float sy = rmin [1] - y;
829
830 // TODO: adjust matrix for subpixel accuracy
831 int nx = floor (rmin [0]);
832 int ny = floor (rmin [1]);
833
834 int new_width = ceil (rmax [0] - rmin [0]);
835 int new_height = ceil (rmax [1] - rmin [1]);
836
837 mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
838
839 composer cc (this, new rxvt_img (s, format, nx, ny, new_width, new_height, repeat));
332 840
333 XTransform xfrm; 841 XTransform xfrm;
334 842
335 for (int i = 0; i < 3; ++i) 843 for (int i = 0; i < 3; ++i)
336 for (int j = 0; j < 3; ++j) 844 for (int j = 0; j < 3; ++j)
337 xfrm.matrix [i][j] = XDoubleToFixed (matrix [i * 3 + j]); 845 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
338 846
339 XRenderSetPictureFilter (dpy, src, "good", 0, 0); 847 XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
340 XRenderSetPictureTransform (dpy, src, &xfrm); 848 XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
341 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, new_width, new_height); 849 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
342 850
343 XRenderFreePicture (dpy, src); 851 return cc;
344 XRenderFreePicture (dpy, dst); 852}
853
854rxvt_img *
855rxvt_img::scale (int new_width, int new_height)
856{
857 if (w == new_width && h == new_height)
858 return clone ();
859
860 int old_repeat_mode = repeat;
861 repeat = RepeatPad; // not right, but xrender can't properly scale it seems
862
863 rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
864
865 repeat = old_repeat_mode;
866 img->repeat = repeat;
345 867
346 return img; 868 return img;
347} 869}
348 870
349rxvt_img * 871rxvt_img *
350rxvt_img::scale (int new_width, int new_height) 872rxvt_img::rotate (int cx, int cy, nv phi)
351{ 873{
352 double matrix[9] = { 874 move (-cx, -cy);
353 w / (double)new_width, 0, 0, 875 rxvt_img *img = transform (mat3x3::rotate (phi));
354 0, h / (double)new_height, 0, 876 move ( cx, cy);
355 0, 0, 1 877 img->move (cx, cy);
356 };
357
358 return transform (new_width, new_height, RepeatNormal, matrix);
359}
360
361rxvt_img *
362rxvt_img::rotate (int new_width, int new_height, int repeat, int x, int y, double phi)
363{
364 double s = sin (phi);
365 double c = cos (phi);
366
367 double matrix[9] = {
368 c, -s, -c * x + s * y + x,
369 s, c, -s * x - c * y + y,
370 0, 0, 1
371 };
372
373 return transform (new_width, new_height, repeat, matrix);
374}
375
376rxvt_img *
377rxvt_img::convert_to (XRenderPictFormat *new_format)
378{
379 rxvt_img *img = new rxvt_img (s, new_format, w, h);
380
381 Display *dpy = s->display->dpy;
382 Picture src = XRenderCreatePicture (dpy, pm, format, 0, 0);
383 Picture dst = XRenderCreatePicture (dpy, img->pm, new_format, 0, 0);
384
385 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);
386
387 XRenderFreePicture (dpy, src);
388 XRenderFreePicture (dpy, dst);
389 878
390 return img; 879 return img;
391} 880}
392 881
882rxvt_img *
883rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
884{
885 if (new_format == format)
886 return clone ();
887
888 composer cc (this, new rxvt_img (s, new_format, x, y, w, h, repeat));
889
890 int op = PictOpSrc;
891
892 if (format->direct.alphaMask && !new_format->direct.alphaMask)
893 {
894 // does it have to be that complicated
895 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
896 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
897
898 op = PictOpOver;
899 }
900
901 XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
902
903 return cc;
904}
905
906rxvt_img *
907rxvt_img::tint (const rgba &c)
908{
909 composer cc (this);
910 cc.mask (true);
911 cc.fill (c);
912
913 XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
914
915 return cc;
916}
917
918rxvt_img *
919rxvt_img::shade (nv factor, rgba c)
920{
921 clamp_it (factor, -1., 1.);
922 factor++;
923
924 if (factor > 1)
925 {
926 c.r = c.r * (2 - factor);
927 c.g = c.g * (2 - factor);
928 c.b = c.b * (2 - factor);
929 }
930 else
931 {
932 c.r = c.r * factor;
933 c.g = c.g * factor;
934 c.b = c.b * factor;
935 }
936
937 rxvt_img *img = this->tint (c);
938
939 if (factor > 1)
940 {
941 c.a = 0xffff;
942 c.r =
943 c.g =
944 c.b = 0xffff * (factor - 1);
945
946 img->brightness (c.r, c.g, c.b, c.a);
947 }
948
949 return img;
950}
951
952rxvt_img *
953rxvt_img::filter (const char *name, int nparams, nv *params)
954{
955 composer cc (this);
956
957 XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
958
959 for (int i = 0; i < nparams; ++i)
960 xparams [i] = XDoubleToFixed (params [i]);
961
962 XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
963
964 XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
965
966 return cc;
967}
968
393#endif 969#endif
394 970

Diff Legend

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