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.19 by root, Tue Jun 5 13:39:26 2012 UTC vs.
Revision 1.102 by root, Sat Jul 7 07:00:17 2012 UTC

1/*----------------------------------------------------------------------*
2 * File: rxvtimg.C
3 *----------------------------------------------------------------------*
4 *
5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2012 Marc Lehmann <schmorp@schmorp.de>
7 * Copyright (c) 2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 *---------------------------------------------------------------------*/
23
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 if (!pb_has_alpha)
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
361 uint32_t v = (255 << 24) | (r << 16) | (g << 8) | b;
362
363 if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch)
364 v = ecb_bswap32 (v);
365
366 *dst++ = v;
367 }
368 else
369 for (int x = 0; x < width; x++)
370 {
371 uint32_t v = *(uint32_t *)src; src += 4;
372
373 if (ecb_big_endian ())
374 v = ecb_bswap32 (v);
375
376 v = ecb_rotl32 (v, 8); // abgr to bgra
377
378 if (!byte_order_mismatch)
379 v = ecb_bswap32 (v);
380
381 *dst++ = v;
382 }
383
384 row += rowstride;
385 line += xi.bytes_per_line;
386 }
387
388 rxvt_img *img = new rxvt_img (s, XRenderFindStandardFormat (dpy, PictStandardARGB32), 0, 0, width, height);
389 img->alloc ();
390
391 GC gc = XCreateGC (dpy, img->pm, 0, 0);
392 XPutImage (dpy, img->pm, gc, &xi, 0, 0, 0, 0, width, height);
393 XFreeGC (dpy, gc);
394
395 free (xi.data);
396
397 return img;
18} 398}
19 399
20rxvt_img * 400rxvt_img *
21rxvt_img::new_from_file (rxvt_screen *s, const char *filename) 401rxvt_img::new_from_file (rxvt_screen *s, const char *filename)
22{ 402{
… …
24 GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err); 404 GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err);
25 405
26 if (!pb) 406 if (!pb)
27 rxvt_fatal ("rxvt_img::new_from_file: %s\n", err->message); 407 rxvt_fatal ("rxvt_img::new_from_file: %s\n", err->message);
28 408
29 rxvt_img *img = new rxvt_img ( 409 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 410
36 img->render_pixbuf (pb, 0, 0, img->w, img->h, 0, 0); 411 g_object_unref (pb);
37 412
38 return img; 413 return img;
39} 414}
40 415
416# endif
417
418void
419rxvt_img::destroy ()
420{
421 if (--ref->cnt)
422 return;
423
424 if (pm && ref->ours)
425 XFreePixmap (s->dpy, pm);
426
427 delete ref;
428}
429
41rxvt_img::~rxvt_img () 430rxvt_img::~rxvt_img ()
42{ 431{
43 if (!shared) 432 destroy ();
44 XFreePixmap (s->display->dpy, pm); 433}
434
435void
436rxvt_img::alloc ()
437{
438 pm = XCreatePixmap (s->dpy, s->display->root, w, h, format->depth);
439 ref = new pixref (w, h);
440}
441
442rxvt_img *
443rxvt_img::new_empty ()
444{
445 rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat);
446 img->alloc ();
447
448 return img;
449}
450
451Picture
452rxvt_img::picture ()
453{
454 Display *dpy = s->dpy;
455
456 XRenderPictureAttributes pa;
457 pa.repeat = repeat;
458 Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
459
460 return pic;
45} 461}
46 462
47void 463void
48rxvt_img::unshare () 464rxvt_img::unshare ()
49{ 465{
50 if (!shared) 466 if (ref->cnt == 1 && ref->ours)
51 return; 467 return;
52 468
469 Pixmap pm2 = XCreatePixmap (s->dpy, s->display->root, ref->w, ref->h, format->depth);
470 GC gc = XCreateGC (s->dpy, pm, 0, 0);
471 XCopyArea (s->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);
472 XFreeGC (s->dpy, gc);
473
474 destroy ();
475
476 pm = pm2;
477 ref = new pixref (ref->w, ref->h);
478}
479
480void
481rxvt_img::fill (const rgba &c, int x, int y, int w, int h)
482{
483 XRenderColor rc = { c.r, c.g, c.b, c.a };
484
485 Display *dpy = s->dpy;
486 Picture src = picture ();
487 XRenderFillRectangle (dpy, PictOpSrc, src, &rc, x, y, w, h);
488 XRenderFreePicture (dpy, src);
489}
490
491void
492rxvt_img::fill (const rgba &c)
493{
494 fill (c, 0, 0, w, h);
495}
496
497void
498rxvt_img::add_alpha ()
499{
500 if (format->direct.alphaMask)
501 return;
502
503 composer cc (this, new rxvt_img (s, find_alpha_format_for (s->dpy, format), x, y, w, h, repeat));
504
505 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
506
53 rxvt_img *img = clone (); 507 rxvt_img *img = cc;
54 508
55 ::swap (pm , img->pm); 509 ::swap (img->ref, ref);
56 ::swap (shared, img->shared); 510 ::swap (img->pm , pm );
57 511
58 delete img; 512 delete img;
59} 513}
60 514
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 515static void
72get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params) 516get_gaussian_kernel (int radius, int width, nv *kernel, XFixed *params)
73{ 517{
74 double sigma = radius / 2.0; 518 nv sigma = radius / 2.0;
75 double scale = sqrt (2.0 * M_PI) * sigma; 519 nv scale = sqrt (2.0 * M_PI) * sigma;
76 double sum = 0.0; 520 nv sum = 0.0;
77 521
78 for (int i = 0; i < width; i++) 522 for (int i = 0; i < width; i++)
79 { 523 {
80 double x = i - width / 2; 524 nv x = i - width / 2;
81 kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale; 525 kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;
82 sum += kernel[i]; 526 sum += kernel[i];
83 } 527 }
84 528
85 params[0] = XDoubleToFixed (width); 529 params[0] = XDoubleToFixed (width);
… …
87 531
88 for (int i = 0; i < width; i++) 532 for (int i = 0; i < width; i++)
89 params[i+2] = XDoubleToFixed (kernel[i] / sum); 533 params[i+2] = XDoubleToFixed (kernel[i] / sum);
90} 534}
91 535
92void 536rxvt_img *
93rxvt_img::blur (int rh, int rv) 537rxvt_img::blur (int rh, int rv)
94{ 538{
95 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV)) 539 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))
96 return; 540 return clone ();
97 541
98 Display *dpy = s->display->dpy; 542 Display *dpy = s->dpy;
99 int size = max (rh, rv) * 2 + 1; 543 int size = max (rh, rv) * 2 + 1;
100 double *kernel = (double *)malloc (size * sizeof (double)); 544 nv *kernel = (nv *)malloc (size * sizeof (nv));
101 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 545 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
546 rxvt_img *img = new_empty ();
102 547
103 XRenderPictureAttributes pa; 548 XRenderPictureAttributes pa;
104
105 pa.repeat = RepeatPad; 549 pa.repeat = RepeatPad;
106 Picture src = XRenderCreatePicture (dpy, pm , format, CPRepeat, &pa); 550 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
551 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
552
107 Pixmap tmp = XCreatePixmap (dpy, pm, w, h, format->depth); 553 Pixmap tmp_pm = XCreatePixmap (dpy, pm, w, h, format->depth);
108 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa); 554 Picture tmp = XRenderCreatePicture (dpy, tmp_pm , format, CPRepeat, &pa);
109 XFreePixmap (dpy, tmp); 555 XFreePixmap (dpy, tmp_pm);
110 556
111 if (kernel && params) 557 if (kernel && params)
112 { 558 {
113 size = rh * 2 + 1; 559 size = rh * 2 + 1;
114 get_gaussian_kernel (rh, size, kernel, params); 560 get_gaussian_kernel (rh, size, kernel, params);
115 561
116 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 562 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
117 XRenderComposite (dpy, 563 XRenderComposite (dpy,
118 PictOpSrc, 564 PictOpSrc,
119 src, 565 src,
566 None,
567 tmp,
568 0, 0,
569 0, 0,
570 0, 0,
571 w, h);
572
573 size = rv * 2 + 1;
574 get_gaussian_kernel (rv, size, kernel, params);
575 ::swap (params[0], params[1]);
576
577 XRenderSetPictureFilter (dpy, tmp, FilterConvolution, params, size+2);
578 XRenderComposite (dpy,
579 PictOpSrc,
580 tmp,
120 None, 581 None,
121 dst, 582 dst,
122 0, 0, 583 0, 0,
123 0, 0, 584 0, 0,
124 0, 0, 585 0, 0,
125 w, h); 586 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 } 587 }
144 588
145 free (kernel); 589 free (kernel);
146 free (params); 590 free (params);
591
147 XRenderFreePicture (dpy, src); 592 XRenderFreePicture (dpy, src);
148 XRenderFreePicture (dpy, dst); 593 XRenderFreePicture (dpy, dst);
149} 594 XRenderFreePicture (dpy, tmp);
150 595
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; 596 return img;
597}
598
599rxvt_img *
600rxvt_img::muladd (nv mul, nv add)
601{
602 // STEP 1: double the image width, fill all odd columns with white (==1)
603
604 composer cc (this, new rxvt_img (s, format, 0, 0, w * 2, h, repeat));
605
606 // why the hell does XRenderSetPictureTransform want a writable matrix :(
607 // that keeps us from just static const'ing this matrix.
608 XTransform h_double = {
609 32768, 0, 0,
610 0, 65536, 0,
611 0, 0, 65536
612 };
613
614 XRenderSetPictureFilter (cc.dpy, cc.src, "nearest", 0, 0);
615 XRenderSetPictureTransform (cc.dpy, cc.src, &h_double);
616 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
617
618 cc.mask (false, 2, 1);
619
620 static const XRenderColor c0 = { 0, 0, 0, 0 };
621 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c0, 0, 0, 1, 1);
622 static const XRenderColor c1 = { 65535, 65535, 65535, 65535 };
623 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c1, 1, 0, 1, 1);
624
625 Picture white = XRenderCreateSolidFill (cc.dpy, &c1);
626
627 XRenderComposite (cc.dpy, PictOpOver, white, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
628
629 XRenderFreePicture (cc.dpy, white);
630
631 // STEP 2: convolve the image with a 3x1 filter
632 // a 2x1 filter would obviously suffice, but given the total lack of specification
633 // for xrender, I expect different xrender implementations to randomly diverge.
634 // we also halve the image, and hope for the best (again, for lack of specs).
635 composer cc2 (cc.dstimg);
636
637 XFixed kernel [] = {
638 XDoubleToFixed (3), XDoubleToFixed (1),
639 XDoubleToFixed (0), XDoubleToFixed (mul), XDoubleToFixed (add)
640 };
641
642 XTransform h_halve = {
643 131072, 0, 0,
644 0, 65536, 0,
645 0, 0, 65536
646 };
647
648 XRenderSetPictureFilter (cc.dpy, cc2.src, "nearest", 0, 0);
649 XRenderSetPictureTransform (cc.dpy, cc2.src, &h_halve);
650 XRenderSetPictureFilter (cc.dpy, cc2.src, FilterConvolution, kernel, ecb_array_length (kernel));
651
652 XRenderComposite (cc.dpy, PictOpSrc, cc2.src, None, cc2.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
653
654 return cc2;
655}
656
657ecb_noinline static void
658extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
659{
660 int32_t x = clamp (c, cl0, cl1);
661 c -= x;
662 xc = x;
663}
664
665ecb_noinline static bool
666extract (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)
667{
668 extract (cl0, cl1, r, xr);
669 extract (cl0, cl1, g, xg);
670 extract (cl0, cl1, b, xb);
671 extract (cl0, cl1, a, xa);
672
673 return xr | xg | xb | xa;
164} 674}
165 675
166void 676void
167rxvt_img::brightness (double r, double g, double b, double a) 677rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
168{ 678{
679 unshare ();
680
169 Display *dpy = s->display->dpy; 681 Display *dpy = s->dpy;
170 Picture src = create_xrender_mask (dpy, pm, True);
171 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 682 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
172 683
684 // loop should not be needed for brightness, as only -1..1 makes sense
685 //while (r | g | b | a)
686 {
687 unsigned short xr, xg, xb, xa;
173 XRenderColor mask_c; 688 XRenderColor mask_c;
174 mask_c.red = float_to_component (r); 689
175 mask_c.green = float_to_component (g); 690 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); 691 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
179 692
180 XRenderComposite (dpy, PictOpAdd, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 693 if (extract (-65535, 0, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
694 {
695 XRenderColor mask_w = { 65535, 65535, 65535, 65535 };
696 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
697 mask_c.red = -mask_c.red; //TODO: verify that doing clamp, assign, and negation does the right thing
698 mask_c.green = -mask_c.green;
699 mask_c.blue = -mask_c.blue;
700 mask_c.alpha = -mask_c.alpha;
701 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
702 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
703 }
704 }
705
706 XRenderFreePicture (dpy, dst);
181} 707}
182 708
183void 709void
184rxvt_img::contrast (double r, double g, double b, double a) 710rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
185{ 711{
186 if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL)) 712 if (r < 0 || g < 0 || b < 0 || a < 0)
187 return; 713 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
188 714
189 Display *dpy = s->display->dpy; 715 // premultiply (yeah, these are not exact, sue me or fix it)
190 Picture src = create_xrender_mask (dpy, pm, True); 716 r = (r * (a >> 8)) >> 8;
191 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 717 g = (g * (a >> 8)) >> 8;
718 b = (b * (a >> 8)) >> 8;
192 719
720 composer cc (this);
721 rxvt_img *img = cc;
722 img->fill (rgba (0, 0, 0, 0));
723
724 cc.mask (true);
725
726 //TODO: this operator does not yet implement some useful contrast
727 while (r | g | b | a)
728 {
729 unsigned short xr, xg, xb, xa;
193 XRenderColor mask_c; 730 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 731
200 XRenderComposite (dpy, PictOpMultiply, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 732 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 { 733 {
271 unsigned char *pixel = row + x * channels; 734 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &mask_c, 0, 0, 1, 1);
272 uint32_t value; 735 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 } 736 }
300
301 row += rowstride;
302 line += ximage->bytes_per_line;
303 } 737 }
304 738
305 XPutImage (dpy, pm, gc, ximage, 0, 0, dst_x, dst_y, width, height); 739 ::swap (img->ref, ref);
306 XDestroyImage (ximage); 740 ::swap (img->pm , pm );
307 XFreeGC (dpy, gc);
308 741
309 return true; 742 delete img;
743}
744
745void
746rxvt_img::draw (rxvt_img *img, int op, nv mask)
747{
748 unshare ();
749
750 composer cc (img, this);
751
752 if (mask != 1.)
753 cc.mask (rgba (0, 0, 0, float_to_component (mask)));
754
755 XRenderComposite (cc.dpy, op, cc.src, cc.msk, cc.dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h);
310} 756}
311 757
312rxvt_img * 758rxvt_img *
313rxvt_img::clone () 759rxvt_img::clone ()
314{ 760{
315 rxvt_img *img = new rxvt_img (s, format, w, h); 761 return new rxvt_img (*this);
316
317 GC gc = XCreateGC (s->display->dpy, pm, 0, 0);
318 XCopyArea (s->display->dpy, pm, img->pm, gc, 0, 0, w, h, 0, 0);
319 XFreeGC (s->display->dpy, gc);
320} 762}
321 763
322rxvt_img * 764rxvt_img *
765rxvt_img::reify ()
766{
767 if (x == 0 && y == 0 && w == ref->w && h == ref->h)
768 return clone ();
769
770 // add an alpha channel if...
771 bool alpha = !format->direct.alphaMask // pixmap has none yet
772 && (x || y) // we need one because of non-zero offset
773 && repeat == RepeatNone; // and we have no good pixels to fill with
774
775 composer cc (this, new rxvt_img (s, alpha ? find_alpha_format_for (s->dpy, format) : format,
776 0, 0, w, h, repeat));
777
778 if (repeat == RepeatNone)
779 {
780 XRenderColor rc = { 0, 0, 0, 0 };
781 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
782 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
783 }
784 else
785 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
786
787 return cc;
788}
789
790rxvt_img *
323rxvt_img::sub_rect (int x, int y, int width, int height, int repeat) 791rxvt_img::sub_rect (int x, int y, int width, int height)
324{ 792{
325 rxvt_img *img = new rxvt_img (s, format, width, height); 793 rxvt_img *img = clone ();
326 794
327 Display *dpy = s->display->dpy; 795 img->x -= x;
328 XRenderPictureAttributes pa; 796 img->y -= y;
329 pa.repeat = repeat;
330 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
331 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
332 797
333 XRenderComposite (dpy, PictOpSrc, src, None, dst, x, y, 0, 0, 0, 0, width, height); 798 if (w != width || h != height)
799 {
800 img->w = width;
801 img->h = height;
334 802
335 XRenderFreePicture (dpy, src); 803 rxvt_img *img2 = img->reify ();
336 XRenderFreePicture (dpy, dst); 804 delete img;
805 img = img2;
806 }
337 807
338 return img; 808 return img;
339} 809}
340 810
341rxvt_img * 811rxvt_img *
342rxvt_img::transform (int new_width, int new_height, double matrix[9], int repeat) 812rxvt_img::transform (const nv matrix[3][3])
343{ 813{
344 rxvt_img *img = new rxvt_img (s, format, new_width, new_height); 814 return transform (mat3x3 (&matrix[0][0]));
815}
345 816
346 Display *dpy = s->display->dpy; 817rxvt_img *
347 XRenderPictureAttributes pa; 818rxvt_img::transform (const nv *matrix)
348 pa.repeat = repeat; 819{
349 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 820 mat3x3 m (matrix);
350 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0); 821
822 // calculate new pixel bounding box coordinates
823 nv rmin[2], rmax[2];
824
825 for (int i = 0; i < 2; ++i)
826 {
827 nv v;
828
829 v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v;
830 v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v);
831 v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
832 v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
833 }
834
835 float sx = rmin [0] - x;
836 float sy = rmin [1] - y;
837
838 // TODO: adjust matrix for subpixel accuracy
839 int nx = floor (rmin [0]);
840 int ny = floor (rmin [1]);
841
842 int new_width = ceil (rmax [0] - rmin [0]);
843 int new_height = ceil (rmax [1] - rmin [1]);
844
845 mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
846
847 composer cc (this, new rxvt_img (s, format, nx, ny, new_width, new_height, repeat));
351 848
352 XTransform xfrm; 849 XTransform xfrm;
353 850
354 for (int i = 0; i < 3; ++i) 851 for (int i = 0; i < 3; ++i)
355 for (int j = 0; j < 3; ++j) 852 for (int j = 0; j < 3; ++j)
356 xfrm.matrix [i][j] = XDoubleToFixed (matrix [i * 3 + j]); 853 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
357 854
358 XRenderSetPictureFilter (dpy, src, "good", 0, 0); 855 XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
359 XRenderSetPictureTransform (dpy, src, &xfrm); 856 XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
360 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, new_width, new_height); 857 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
361 858
362 XRenderFreePicture (dpy, src); 859 return cc;
363 XRenderFreePicture (dpy, dst); 860}
861
862rxvt_img *
863rxvt_img::scale (int new_width, int new_height)
864{
865 if (w == new_width && h == new_height)
866 return clone ();
867
868 int old_repeat_mode = repeat;
869 repeat = RepeatPad; // not right, but xrender can't properly scale it seems
870
871 rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
872
873 repeat = old_repeat_mode;
874 img->repeat = repeat;
364 875
365 return img; 876 return img;
366} 877}
367 878
368rxvt_img * 879rxvt_img *
369rxvt_img::scale (int new_width, int new_height) 880rxvt_img::rotate (int cx, int cy, nv phi)
370{ 881{
371 double matrix[9] = { 882 move (-cx, -cy);
372 w / (double)new_width, 0, 0, 883 rxvt_img *img = transform (mat3x3::rotate (phi));
373 0, h / (double)new_height, 0, 884 move ( cx, cy);
374 0, 0, 1 885 img->move (cx, cy);
375 };
376
377 return transform (new_width, new_height, matrix);
378}
379
380rxvt_img *
381rxvt_img::rotate (int new_width, int new_height, int x, int y, double phi, int repeat)
382{
383 double s = sin (phi);
384 double c = cos (phi);
385
386 double matrix[9] = {
387 c, -s, -c * x + s * y + x,
388 s, c, -s * x - c * y + y,
389 0, 0, 1
390 };
391
392 return transform (new_width, new_height, matrix, repeat);
393}
394
395rxvt_img *
396rxvt_img::convert_to (XRenderPictFormat *new_format)
397{
398 rxvt_img *img = new rxvt_img (s, new_format, w, h);
399
400 Display *dpy = s->display->dpy;
401 Picture src = XRenderCreatePicture (dpy, pm, format, 0, 0);
402 Picture dst = XRenderCreatePicture (dpy, img->pm, new_format, 0, 0);
403
404 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);
405
406 XRenderFreePicture (dpy, src);
407 XRenderFreePicture (dpy, dst);
408 886
409 return img; 887 return img;
410} 888}
411 889
890rxvt_img *
891rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
892{
893 if (new_format == format)
894 return clone ();
895
896 composer cc (this, new rxvt_img (s, new_format, x, y, w, h, repeat));
897
898 int op = PictOpSrc;
899
900 if (format->direct.alphaMask && !new_format->direct.alphaMask)
901 {
902 // does it have to be that complicated
903 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
904 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
905
906 op = PictOpOver;
907 }
908
909 XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
910
911 return cc;
912}
913
914rxvt_img *
915rxvt_img::tint (const rgba &c)
916{
917 composer cc (this);
918 cc.mask (true);
919 cc.fill (c);
920
921 XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
922
923 return cc;
924}
925
926rxvt_img *
927rxvt_img::filter (const char *name, int nparams, nv *params)
928{
929 composer cc (this);
930
931 XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
932
933 for (int i = 0; i < nparams; ++i)
934 xparams [i] = XDoubleToFixed (params [i]);
935
936 XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
937
938 XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
939
940 return cc;
941}
942
412#endif 943#endif
413 944

Diff Legend

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