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.109 by sf-exg, Sat Jul 15 08:16:31 2017 UTC

1/*----------------------------------------------------------------------*
2 * File: rxvtimg.C
3 *----------------------------------------------------------------------*
4 *
5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2012 Marc Lehmann <schmorp@schmorp.de>
7 * Copyright (c) 2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 3 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 *---------------------------------------------------------------------*/
23
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->d->dpy;
170 src = srcimg->picture ();
171 dst = this->dstimg->picture ();
172 }
173
174 ecb_noinline
175 void mask (bool rgb = true, int w = 1, int h = 1)
176 {
177 Pixmap pixmap = XCreatePixmap (dpy, srcimg->pm, w, h, rgb ? 32 : 8);
178
179 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, rgb ? PictStandardARGB32 : PictStandardA8);
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) 252: d(screen->display), x(x), y(y), w(width), h(height), format(format), repeat(repeat),
253 pm(0), ref(0)
11{ 254{
12 pm = XCreatePixmap (s->display->dpy, s->display->root, w, h, format->depth);
13} 255}
14 256
15rxvt_img::rxvt_img (rxvt_screen *screen, XRenderPictFormat *format, int width, int height, Pixmap pixmap) 257rxvt_img::rxvt_img (rxvt_display *display, XRenderPictFormat *format, int x, int y, int width, int height, int repeat)
16: s(screen), pm(pixmap), w(width), h(height), format(format), shared(false) 258: d(display), x(x), y(y), w(width), h(height), format(format), repeat(repeat),
259 pm(0), ref(0)
17{ 260{
261}
262
263rxvt_img::rxvt_img (const rxvt_img &img)
264: d(img.d), x(img.x), y(img.y), w(img.w), h(img.h), format(img.format), repeat(img.repeat), pm(img.pm), ref(img.ref)
265{
266 ++ref->cnt;
267}
268
269rxvt_img *
270rxvt_img::new_from_root (rxvt_screen *s)
271{
272 Display *dpy = s->dpy;
273 unsigned int root_pm_w, root_pm_h;
274 Pixmap root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_XROOTPMAP_ID]);
275 if (root_pixmap == None)
276 root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_ESETROOT_PMAP_ID]);
277
278 if (root_pixmap == None)
279 return 0;
280
281 Window wdummy;
282 int idummy;
283 unsigned int udummy;
284
285 if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pm_w, &root_pm_h, &udummy, &udummy))
286 return 0;
287
288 rxvt_img *img = new rxvt_img (
289 s,
290 XRenderFindVisualFormat (dpy, DefaultVisual (dpy, s->display->screen)),
291 0,
292 0,
293 root_pm_w,
294 root_pm_h
295 );
296
297 img->pm = root_pixmap;
298 img->ref = new pixref (root_pm_w, root_pm_h);
299 img->ref->ours = false;
300
301 return img;
302}
303
304# if HAVE_PIXBUF
305
306rxvt_img *
307rxvt_img::new_from_pixbuf (rxvt_screen *s, GdkPixbuf *pb)
308{
309 Display *dpy = s->dpy;
310
311 int width = gdk_pixbuf_get_width (pb);
312 int height = gdk_pixbuf_get_height (pb);
313
314 if (width > 32767 || height > 32767) // well, we *could* upload in chunks
315 rxvt_fatal ("rxvt_img::new_from_pixbuf: image too big (maximum size 32768x32768).\n");
316
317 // since we require rgb24/argb32 formats from xrender we assume
318 // that both 24 and 32 bpp MUST be supported by any screen that supports xrender
319
320 int byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
321
322 XImage xi;
323
324 xi.width = width;
325 xi.height = height;
326 xi.xoffset = 0;
327 xi.format = ZPixmap;
328 xi.byte_order = ImageByteOrder (dpy);
329 xi.bitmap_unit = 0; //XY only, unused
330 xi.bitmap_bit_order = 0; //XY only, unused
331 xi.bitmap_pad = BitmapPad (dpy);
332 xi.depth = 32;
333 xi.bytes_per_line = 0;
334 xi.bits_per_pixel = 32; //Z only
335 xi.red_mask = 0x00000000; //Z only, unused
336 xi.green_mask = 0x00000000; //Z only, unused
337 xi.blue_mask = 0x00000000; //Z only, unused
338 xi.obdata = 0; // probably unused
339
340 bool byte_order_mismatch = byte_order != xi.byte_order;
341
342 if (!XInitImage (&xi))
343 rxvt_fatal ("unable to initialise ximage, please report.\n");
344
345 if (height > INT_MAX / xi.bytes_per_line)
346 rxvt_fatal ("rxvt_img::new_from_pixbuf: image too big for Xlib.\n");
347
348 xi.data = (char *)rxvt_malloc (height * xi.bytes_per_line);
349
350 int rowstride = gdk_pixbuf_get_rowstride (pb);
351 bool pb_has_alpha = gdk_pixbuf_get_has_alpha (pb);
352 unsigned char *row = gdk_pixbuf_get_pixels (pb);
353
354 char *line = xi.data;
355
356 for (int y = 0; y < height; y++)
357 {
358 unsigned char *src = row;
359 uint32_t *dst = (uint32_t *)line;
360
361 for (int x = 0; x < width; x++)
362 {
363 uint8_t r = *src++;
364 uint8_t g = *src++;
365 uint8_t b = *src++;
366 uint8_t a = *src;
367
368 // this is done so it can be jump-free, but newer gcc's clone inner the loop
369 a = pb_has_alpha ? a : 255;
370 src += pb_has_alpha;
371
372 r = (r * a + 127) / 255;
373 g = (g * a + 127) / 255;
374 b = (b * a + 127) / 255;
375
376 uint32_t v = (a << 24) | (r << 16) | (g << 8) | b;
377
378 if (ecb_big_endian () ? !byte_order_mismatch : 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 (d->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 (d->dpy, d->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 (d, format, x, y, w, h, repeat);
446 img->alloc ();
447
448 return img;
449}
450
451Picture
452rxvt_img::picture ()
453{
454 Display *dpy = d->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 (d->dpy, d->root, ref->w, ref->h, format->depth);
470 GC gc = XCreateGC (d->dpy, pm, 0, 0);
471 XCopyArea (d->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);
472 XFreeGC (d->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 = d->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 (d, find_alpha_format_for (d->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 (!(d->flags & DISPLAY_HAS_RENDER_CONV))
96 return; 540 return clone ();
97 541
98 Display *dpy = s->display->dpy; 542 Display *dpy = d->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 = rxvt_temp_buf<XFixed> (size + 2);
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
147 XRenderFreePicture (dpy, src); 591 XRenderFreePicture (dpy, src);
148 XRenderFreePicture (dpy, dst); 592 XRenderFreePicture (dpy, dst);
149} 593 XRenderFreePicture (dpy, tmp);
150 594
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; 595 return img;
596}
597
598rxvt_img *
599rxvt_img::muladd (nv mul, nv add)
600{
601 // STEP 1: double the image width, fill all odd columns with white (==1)
602
603 composer cc (this, new rxvt_img (d, format, 0, 0, w * 2, h, repeat));
604
605 // why the hell does XRenderSetPictureTransform want a writable matrix :(
606 // that keeps us from just static const'ing this matrix.
607 XTransform h_double = {
608 0x08000, 0, 0,
609 0, 0x10000, 0,
610 0, 0, 0x10000
611 };
612
613 XRenderSetPictureFilter (cc.dpy, cc.src, "nearest", 0, 0);
614 XRenderSetPictureTransform (cc.dpy, cc.src, &h_double);
615 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
616
617 cc.mask (false, 2, 1);
618
619 static const XRenderColor c0 = { 0, 0, 0, 0 };
620 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c0, 0, 0, 1, 1);
621 static const XRenderColor c1 = { 65535, 65535, 65535, 65535 };
622 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c1, 1, 0, 1, 1);
623
624 Picture white = XRenderCreateSolidFill (cc.dpy, &c1);
625
626 XRenderComposite (cc.dpy, PictOpOver, white, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
627
628 XRenderFreePicture (cc.dpy, white);
629
630 // STEP 2: convolve the image with a 3x1 filter
631 // a 2x1 filter would obviously suffice, but given the total lack of specification
632 // for xrender, I expect different xrender implementations to randomly diverge.
633 // we also halve the image, and hope for the best (again, for lack of specs).
634 composer cc2 (cc.dstimg);
635
636 XFixed kernel [] = {
637 XDoubleToFixed (3), XDoubleToFixed (1),
638 XDoubleToFixed (0), XDoubleToFixed (mul), XDoubleToFixed (add)
639 };
640
641 XTransform h_halve = {
642 0x20000, 0, 0,
643 0, 0x10000, 0,
644 0, 0, 0x10000
645 };
646
647 XRenderSetPictureFilter (cc.dpy, cc2.src, "nearest", 0, 0);
648 XRenderSetPictureTransform (cc.dpy, cc2.src, &h_halve);
649 XRenderSetPictureFilter (cc.dpy, cc2.src, FilterConvolution, kernel, ecb_array_length (kernel));
650
651 XRenderComposite (cc.dpy, PictOpSrc, cc2.src, None, cc2.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
652
653 return cc2;
654}
655
656ecb_noinline static void
657extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
658{
659 int32_t x = clamp (c, cl0, cl1);
660 c -= x;
661 xc = x;
662}
663
664ecb_noinline static bool
665extract (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)
666{
667 extract (cl0, cl1, r, xr);
668 extract (cl0, cl1, g, xg);
669 extract (cl0, cl1, b, xb);
670 extract (cl0, cl1, a, xa);
671
672 return xr | xg | xb | xa;
164} 673}
165 674
166void 675void
167rxvt_img::brightness (double r, double g, double b, double a) 676rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
168{ 677{
678 unshare ();
679
169 Display *dpy = s->display->dpy; 680 Display *dpy = d->dpy;
170 Picture src = create_xrender_mask (dpy, pm, True);
171 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 681 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
172 682
683 // loop should not be needed for brightness, as only -1..1 makes sense
684 //while (r | g | b | a)
685 {
686 unsigned short xr, xg, xb, xa;
173 XRenderColor mask_c; 687 XRenderColor mask_c;
174 mask_c.red = float_to_component (r); 688
175 mask_c.green = float_to_component (g); 689 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); 690 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
179 691
180 XRenderComposite (dpy, PictOpAdd, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 692 if (extract (-65535, 0, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
693 {
694 XRenderColor mask_w = { 65535, 65535, 65535, 65535 };
695 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
696 mask_c.red = -mask_c.red; //TODO: verify that doing clamp, assign, and negation does the right thing
697 mask_c.green = -mask_c.green;
698 mask_c.blue = -mask_c.blue;
699 mask_c.alpha = -mask_c.alpha;
700 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
701 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
702 }
703 }
704
705 XRenderFreePicture (dpy, dst);
181} 706}
182 707
183void 708void
184rxvt_img::contrast (double r, double g, double b, double a) 709rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
185{ 710{
186 if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL)) 711 if (r < 0 || g < 0 || b < 0 || a < 0)
187 return; 712 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
188 713
189 Display *dpy = s->display->dpy; 714 // premultiply (yeah, these are not exact, sue me or fix it)
190 Picture src = create_xrender_mask (dpy, pm, True); 715 r = (r * (a >> 8)) >> 8;
191 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 716 g = (g * (a >> 8)) >> 8;
717 b = (b * (a >> 8)) >> 8;
192 718
719 composer cc (this);
720 rxvt_img *img = cc;
721 img->fill (rgba (0, 0, 0, 0));
722
723 cc.mask (true);
724
725 //TODO: this operator does not yet implement some useful contrast
726 while (r | g | b | a)
727 {
728 unsigned short xr, xg, xb, xa;
193 XRenderColor mask_c; 729 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 730
200 XRenderComposite (dpy, PictOpMultiply, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 731 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 { 732 {
271 unsigned char *pixel = row + x * channels; 733 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &mask_c, 0, 0, 1, 1);
272 uint32_t value; 734 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 } 735 }
300
301 row += rowstride;
302 line += ximage->bytes_per_line;
303 } 736 }
304 737
305 XPutImage (dpy, pm, gc, ximage, 0, 0, dst_x, dst_y, width, height); 738 ::swap (img->ref, ref);
306 XDestroyImage (ximage); 739 ::swap (img->pm , pm );
307 XFreeGC (dpy, gc);
308 740
309 return true; 741 delete img;
742}
743
744void
745rxvt_img::draw (rxvt_img *img, int op, nv mask)
746{
747 unshare ();
748
749 composer cc (img, this);
750
751 if (mask != 1.)
752 cc.mask (rgba (0, 0, 0, float_to_component (mask)));
753
754 XRenderComposite (cc.dpy, op, cc.src, cc.msk, cc.dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h);
310} 755}
311 756
312rxvt_img * 757rxvt_img *
313rxvt_img::clone () 758rxvt_img::clone ()
314{ 759{
315 rxvt_img *img = new rxvt_img (s, format, w, h); 760 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} 761}
321 762
322rxvt_img * 763rxvt_img *
764rxvt_img::reify ()
765{
766 if (x == 0 && y == 0 && w == ref->w && h == ref->h)
767 return clone ();
768
769 // add an alpha channel if...
770 bool alpha = !format->direct.alphaMask // pixmap has none yet
771 && (x || y) // we need one because of non-zero offset
772 && repeat == RepeatNone; // and we have no good pixels to fill with
773
774 composer cc (this, new rxvt_img (d, alpha ? find_alpha_format_for (d->dpy, format) : format,
775 0, 0, w, h, repeat));
776
777 if (repeat == RepeatNone)
778 {
779 XRenderColor rc = { 0, 0, 0, 0 };
780 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
781 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
782 }
783 else
784 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
785
786 return cc;
787}
788
789rxvt_img *
323rxvt_img::sub_rect (int x, int y, int width, int height, int repeat) 790rxvt_img::sub_rect (int x, int y, int width, int height)
324{ 791{
325 rxvt_img *img = new rxvt_img (s, format, width, height); 792 rxvt_img *img = clone ();
326 793
327 Display *dpy = s->display->dpy; 794 img->x -= x;
328 XRenderPictureAttributes pa; 795 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 796
333 XRenderComposite (dpy, PictOpSrc, src, None, dst, x, y, 0, 0, 0, 0, width, height); 797 if (w != width || h != height)
798 {
799 img->w = width;
800 img->h = height;
334 801
335 XRenderFreePicture (dpy, src); 802 rxvt_img *img2 = img->reify ();
336 XRenderFreePicture (dpy, dst); 803 delete img;
804 img = img2;
805 }
337 806
338 return img; 807 return img;
339} 808}
340 809
341rxvt_img * 810rxvt_img *
342rxvt_img::transform (int new_width, int new_height, double matrix[9], int repeat) 811rxvt_img::transform (const nv matrix[3][3])
343{ 812{
344 rxvt_img *img = new rxvt_img (s, format, new_width, new_height); 813 return transform (mat3x3 (&matrix[0][0]));
814}
345 815
346 Display *dpy = s->display->dpy; 816rxvt_img *
347 XRenderPictureAttributes pa; 817rxvt_img::transform (const nv *matrix)
348 pa.repeat = repeat; 818{
349 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 819 mat3x3 m (matrix);
350 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0); 820
821 // calculate new pixel bounding box coordinates
822 nv rmin[2], rmax[2];
823
824 for (int i = 0; i < 2; ++i)
825 {
826 nv v;
827
828 v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v;
829 v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v);
830 v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
831 v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
832 }
833
834 float sx = rmin [0] - x;
835 float sy = rmin [1] - y;
836
837 // TODO: adjust matrix for subpixel accuracy
838 int nx = floor (rmin [0]);
839 int ny = floor (rmin [1]);
840
841 int new_width = ceil (rmax [0] - rmin [0]);
842 int new_height = ceil (rmax [1] - rmin [1]);
843
844 mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
845
846 composer cc (this, new rxvt_img (d, format, nx, ny, new_width, new_height, repeat));
351 847
352 XTransform xfrm; 848 XTransform xfrm;
353 849
354 for (int i = 0; i < 3; ++i) 850 for (int i = 0; i < 3; ++i)
355 for (int j = 0; j < 3; ++j) 851 for (int j = 0; j < 3; ++j)
356 xfrm.matrix [i][j] = XDoubleToFixed (matrix [i * 3 + j]); 852 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
357 853
358 XRenderSetPictureFilter (dpy, src, "good", 0, 0); 854 XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
359 XRenderSetPictureTransform (dpy, src, &xfrm); 855 XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
360 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, new_width, new_height); 856 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
361 857
362 XRenderFreePicture (dpy, src); 858 return cc;
363 XRenderFreePicture (dpy, dst); 859}
860
861rxvt_img *
862rxvt_img::scale (int new_width, int new_height)
863{
864 if (w == new_width && h == new_height)
865 return clone ();
866
867 int old_repeat_mode = repeat;
868 repeat = RepeatPad; // not right, but xrender can't properly scale it seems
869
870 rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
871
872 repeat = old_repeat_mode;
873 img->repeat = repeat;
364 874
365 return img; 875 return img;
366} 876}
367 877
368rxvt_img * 878rxvt_img *
369rxvt_img::scale (int new_width, int new_height) 879rxvt_img::rotate (int cx, int cy, nv phi)
370{ 880{
371 double matrix[9] = { 881 move (-cx, -cy);
372 w / (double)new_width, 0, 0, 882 rxvt_img *img = transform (mat3x3::rotate (phi));
373 0, h / (double)new_height, 0, 883 move ( cx, cy);
374 0, 0, 1 884 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 885
409 return img; 886 return img;
410} 887}
411 888
889rxvt_img *
890rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
891{
892 if (new_format == format)
893 return clone ();
894
895 composer cc (this, new rxvt_img (d, new_format, x, y, w, h, repeat));
896
897 int op = PictOpSrc;
898
899 if (format->direct.alphaMask && !new_format->direct.alphaMask)
900 {
901 // does it have to be that complicated
902 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
903 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
904
905 op = PictOpOver;
906 }
907
908 XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
909
910 return cc;
911}
912
913rxvt_img *
914rxvt_img::tint (const rgba &c)
915{
916 composer cc (this);
917 cc.mask (true);
918 cc.fill (c);
919
920 XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
921
922 return cc;
923}
924
925rxvt_img *
926rxvt_img::shade (nv factor, rgba c)
927{
928 clamp_it (factor, -1., 1.);
929 factor++;
930
931 if (factor > 1)
932 {
933 c.r = c.r * (2 - factor);
934 c.g = c.g * (2 - factor);
935 c.b = c.b * (2 - factor);
936 }
937 else
938 {
939 c.r = c.r * factor;
940 c.g = c.g * factor;
941 c.b = c.b * factor;
942 }
943
944 rxvt_img *img = this->tint (c);
945
946 if (factor > 1)
947 {
948 c.a = 0xffff;
949 c.r =
950 c.g =
951 c.b = 0xffff * (factor - 1);
952
953 img->brightness (c.r, c.g, c.b, c.a);
954 }
955
956 return img;
957}
958
959rxvt_img *
960rxvt_img::filter (const char *name, int nparams, nv *params)
961{
962 composer cc (this);
963
964 XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
965
966 for (int i = 0; i < nparams; ++i)
967 xparams [i] = XDoubleToFixed (params [i]);
968
969 XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
970
971 XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
972
973 return cc;
974}
975
412#endif 976#endif
413 977

Diff Legend

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