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

Comparing rxvt-unicode/src/rxvtimg.C (file contents):
Revision 1.11 by root, Mon Jun 4 15:15:49 2012 UTC vs.
Revision 1.110 by root, Tue Sep 17 18:06:37 2019 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{
23 GError *err = 0; 403 GError *err = 0;
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)
407 try
408 {
27 rxvt_fatal ("rxvt_img::new_from_file: %s\n", err->message); 409 rxvt_fatal ("rxvt_img::new_from_file: %s\n", err->message);
410 }
411 catch (...)
412 {
413 g_error_free (err);
414 throw;
415 }
28 416
29 rxvt_img *img = new rxvt_img ( 417 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 418
36 img->render (pb, 0, 0, img->w, img->h, 0, 0); 419 g_object_unref (pb);
37 420
38 return img; 421 return img;
39} 422}
40 423
424# endif
425
426void
427rxvt_img::destroy ()
428{
429 if (--ref->cnt)
430 return;
431
432 if (pm && ref->ours)
433 XFreePixmap (d->dpy, pm);
434
435 delete ref;
436}
437
41rxvt_img::~rxvt_img () 438rxvt_img::~rxvt_img ()
42{ 439{
43 if (!shared) 440 destroy ();
44 XFreePixmap (s->display->dpy, pm); 441}
442
443void
444rxvt_img::alloc ()
445{
446 pm = XCreatePixmap (d->dpy, d->root, w, h, format->depth);
447 ref = new pixref (w, h);
448}
449
450rxvt_img *
451rxvt_img::new_empty ()
452{
453 rxvt_img *img = new rxvt_img (d, format, x, y, w, h, repeat);
454 img->alloc ();
455
456 return img;
457}
458
459Picture
460rxvt_img::picture ()
461{
462 Display *dpy = d->dpy;
463
464 XRenderPictureAttributes pa;
465 pa.repeat = repeat;
466 Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
467
468 return pic;
45} 469}
46 470
47void 471void
48rxvt_img::unshare () 472rxvt_img::unshare ()
49{ 473{
50 if (!shared) 474 if (ref->cnt == 1 && ref->ours)
51 return; 475 return;
52 476
477 Pixmap pm2 = XCreatePixmap (d->dpy, d->root, ref->w, ref->h, format->depth);
478 GC gc = XCreateGC (d->dpy, pm, 0, 0);
479 XCopyArea (d->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);
480 XFreeGC (d->dpy, gc);
481
482 destroy ();
483
484 pm = pm2;
485 ref = new pixref (ref->w, ref->h);
486}
487
488void
489rxvt_img::fill (const rgba &c, int x, int y, int w, int h)
490{
491 XRenderColor rc = { c.r, c.g, c.b, c.a };
492
493 Display *dpy = d->dpy;
494 Picture src = picture ();
495 XRenderFillRectangle (dpy, PictOpSrc, src, &rc, x, y, w, h);
496 XRenderFreePicture (dpy, src);
497}
498
499void
500rxvt_img::fill (const rgba &c)
501{
502 fill (c, 0, 0, w, h);
503}
504
505void
506rxvt_img::add_alpha ()
507{
508 if (format->direct.alphaMask)
509 return;
510
511 composer cc (this, new rxvt_img (d, find_alpha_format_for (d->dpy, format), x, y, w, h, repeat));
512
513 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
514
53 rxvt_img *img = clone (); 515 rxvt_img *img = cc;
54 516
55 ::swap (pm , img->pm); 517 ::swap (img->ref, ref);
56 ::swap (shared, img->shared); 518 ::swap (img->pm , pm );
57 519
58 delete img; 520 delete img;
59} 521}
60 522
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 523static void
72get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params) 524get_gaussian_kernel (int radius, int width, nv *kernel, XFixed *params)
73{ 525{
74 double sigma = radius / 2.0; 526 nv sigma = radius / 2.0;
75 double scale = sqrt (2.0 * M_PI) * sigma; 527 nv scale = sqrt (2.0 * M_PI) * sigma;
76 double sum = 0.0; 528 nv sum = 0.0;
77 529
78 for (int i = 0; i < width; i++) 530 for (int i = 0; i < width; i++)
79 { 531 {
80 double x = i - width / 2; 532 nv x = i - width / 2;
81 kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale; 533 kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;
82 sum += kernel[i]; 534 sum += kernel[i];
83 } 535 }
84 536
85 params[0] = XDoubleToFixed (width); 537 params[0] = XDoubleToFixed (width);
… …
87 539
88 for (int i = 0; i < width; i++) 540 for (int i = 0; i < width; i++)
89 params[i+2] = XDoubleToFixed (kernel[i] / sum); 541 params[i+2] = XDoubleToFixed (kernel[i] / sum);
90} 542}
91 543
92void 544rxvt_img *
93rxvt_img::blur (int rh, int rv) 545rxvt_img::blur (int rh, int rv)
94{ 546{
95 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV)) 547 if (!(d->flags & DISPLAY_HAS_RENDER_CONV))
96 return; 548 return clone ();
97 549
98 Display *dpy = s->display->dpy; 550 Display *dpy = d->dpy;
99 int size = max (rh, rv) * 2 + 1; 551 int size = max (rh, rv) * 2 + 1;
100 double *kernel = (double *)malloc (size * sizeof (double)); 552 nv *kernel = (nv *)malloc (size * sizeof (nv));
101 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 553 XFixed *params = rxvt_temp_buf<XFixed> (size + 2);
554 rxvt_img *img = new_empty ();
102 555
103 XRenderPictureAttributes pa; 556 XRenderPictureAttributes pa;
104
105 pa.repeat = RepeatPad; 557 pa.repeat = RepeatPad;
106 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 558 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
559 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
560
107 Pixmap tmp = XCreatePixmap (dpy, pm, w, h, format->depth); 561 Pixmap tmp_pm = XCreatePixmap (dpy, pm, w, h, format->depth);
108 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa); 562 Picture tmp = XRenderCreatePicture (dpy, tmp_pm , format, CPRepeat, &pa);
109 XFreePixmap (dpy, tmp); 563 XFreePixmap (dpy, tmp_pm);
110 564
111 if (kernel && params) 565 if (kernel && params)
112 { 566 {
113 size = rh * 2 + 1; 567 size = rh * 2 + 1;
114 get_gaussian_kernel (rh, size, kernel, params); 568 get_gaussian_kernel (rh, size, kernel, params);
115 569
116 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 570 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
117 XRenderComposite (dpy, 571 XRenderComposite (dpy,
118 PictOpSrc, 572 PictOpSrc,
119 src, 573 src,
574 None,
575 tmp,
576 0, 0,
577 0, 0,
578 0, 0,
579 w, h);
580
581 size = rv * 2 + 1;
582 get_gaussian_kernel (rv, size, kernel, params);
583 ::swap (params[0], params[1]);
584
585 XRenderSetPictureFilter (dpy, tmp, FilterConvolution, params, size+2);
586 XRenderComposite (dpy,
587 PictOpSrc,
588 tmp,
120 None, 589 None,
121 dst, 590 dst,
122 0, 0, 591 0, 0,
123 0, 0, 592 0, 0,
124 0, 0, 593 0, 0,
125 w, h); 594 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 } 595 }
144 596
145 free (kernel); 597 free (kernel);
146 free (params); 598
147 XRenderFreePicture (dpy, src); 599 XRenderFreePicture (dpy, src);
148 XRenderFreePicture (dpy, dst); 600 XRenderFreePicture (dpy, dst);
149} 601 XRenderFreePicture (dpy, tmp);
150 602
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; 603 return img;
604}
605
606rxvt_img *
607rxvt_img::muladd (nv mul, nv add)
608{
609 // STEP 1: double the image width, fill all odd columns with white (==1)
610
611 composer cc (this, new rxvt_img (d, format, 0, 0, w * 2, h, repeat));
612
613 // why the hell does XRenderSetPictureTransform want a writable matrix :(
614 // that keeps us from just static const'ing this matrix.
615 XTransform h_double = {
616 0x08000, 0, 0,
617 0, 0x10000, 0,
618 0, 0, 0x10000
619 };
620
621 XRenderSetPictureFilter (cc.dpy, cc.src, "nearest", 0, 0);
622 XRenderSetPictureTransform (cc.dpy, cc.src, &h_double);
623 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
624
625 cc.mask (false, 2, 1);
626
627 static const XRenderColor c0 = { 0, 0, 0, 0 };
628 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c0, 0, 0, 1, 1);
629 static const XRenderColor c1 = { 65535, 65535, 65535, 65535 };
630 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c1, 1, 0, 1, 1);
631
632 Picture white = XRenderCreateSolidFill (cc.dpy, &c1);
633
634 XRenderComposite (cc.dpy, PictOpOver, white, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
635
636 XRenderFreePicture (cc.dpy, white);
637
638 // STEP 2: convolve the image with a 3x1 filter
639 // a 2x1 filter would obviously suffice, but given the total lack of specification
640 // for xrender, I expect different xrender implementations to randomly diverge.
641 // we also halve the image, and hope for the best (again, for lack of specs).
642 composer cc2 (cc.dstimg);
643
644 XFixed kernel [] = {
645 XDoubleToFixed (3), XDoubleToFixed (1),
646 XDoubleToFixed (0), XDoubleToFixed (mul), XDoubleToFixed (add)
647 };
648
649 XTransform h_halve = {
650 0x20000, 0, 0,
651 0, 0x10000, 0,
652 0, 0, 0x10000
653 };
654
655 XRenderSetPictureFilter (cc.dpy, cc2.src, "nearest", 0, 0);
656 XRenderSetPictureTransform (cc.dpy, cc2.src, &h_halve);
657 XRenderSetPictureFilter (cc.dpy, cc2.src, FilterConvolution, kernel, ecb_array_length (kernel));
658
659 XRenderComposite (cc.dpy, PictOpSrc, cc2.src, None, cc2.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
660
661 return cc2;
662}
663
664ecb_noinline static void
665extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
666{
667 int32_t x = clamp (c, cl0, cl1);
668 c -= x;
669 xc = x;
670}
671
672ecb_noinline static bool
673extract (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)
674{
675 extract (cl0, cl1, r, xr);
676 extract (cl0, cl1, g, xg);
677 extract (cl0, cl1, b, xb);
678 extract (cl0, cl1, a, xa);
679
680 return xr | xg | xb | xa;
164} 681}
165 682
166void 683void
167rxvt_img::brightness (double r, double g, double b, double a) 684rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
168{ 685{
686 unshare ();
687
169 Display *dpy = s->display->dpy; 688 Display *dpy = d->dpy;
170 Picture src = create_xrender_mask (dpy, pm, True);
171 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 689 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
172 690
691 // loop should not be needed for brightness, as only -1..1 makes sense
692 //while (r | g | b | a)
693 {
694 unsigned short xr, xg, xb, xa;
173 XRenderColor mask_c; 695 XRenderColor mask_c;
174 mask_c.red = float_to_component (r); 696
175 mask_c.green = float_to_component (g); 697 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); 698 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
179 699
180 XRenderComposite (dpy, PictOpAdd, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 700 if (extract (-65535, 0, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
701 {
702 XRenderColor mask_w = { 65535, 65535, 65535, 65535 };
703 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
704 mask_c.red = -mask_c.red; //TODO: verify that doing clamp, assign, and negation does the right thing
705 mask_c.green = -mask_c.green;
706 mask_c.blue = -mask_c.blue;
707 mask_c.alpha = -mask_c.alpha;
708 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
709 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
710 }
711 }
712
713 XRenderFreePicture (dpy, dst);
181} 714}
182 715
183void 716void
184rxvt_img::contrast (double r, double g, double b, double a) 717rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
185{ 718{
186 if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL)) 719 if (r < 0 || g < 0 || b < 0 || a < 0)
187 return; 720 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
188 721
189 Display *dpy = s->display->dpy; 722 // premultiply (yeah, these are not exact, sue me or fix it)
190 Picture src = create_xrender_mask (dpy, pm, True); 723 r = (r * (a >> 8)) >> 8;
191 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 724 g = (g * (a >> 8)) >> 8;
725 b = (b * (a >> 8)) >> 8;
192 726
727 composer cc (this);
728 rxvt_img *img = cc;
729 img->fill (rgba (0, 0, 0, 0));
730
731 cc.mask (true);
732
733 //TODO: this operator does not yet implement some useful contrast
734 while (r | g | b | a)
735 {
736 unsigned short xr, xg, xb, xa;
193 XRenderColor mask_c; 737 XRenderColor mask_c;
194 mask_c.red = float_to_component (r); 738
195 mask_c.green = float_to_component (g); 739 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
196 mask_c.blue = float_to_component (b); 740 {
197 mask_c.alpha = float_to_component (a);
198 XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1); 741 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &mask_c, 0, 0, 1, 1);
199
200 XRenderComposite (dpy, PictOpMultiply, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 742 XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
743 }
744 }
745
746 ::swap (img->ref, ref);
747 ::swap (img->pm , pm );
748
749 delete img;
201} 750}
202 751
203void 752void
204rxvt_img::render (GdkPixbuf *pixbuf, int src_x, int src_y, int width, int height, int dst_x, int dst_y) 753rxvt_img::draw (rxvt_img *img, int op, nv mask)
205{ 754{
206 //TODO 755 unshare ();
756
757 composer cc (img, this);
758
759 if (mask != 1.)
760 cc.mask (rgba (0, 0, 0, float_to_component (mask)));
761
762 XRenderComposite (cc.dpy, op, cc.src, cc.msk, cc.dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h);
207} 763}
208 764
209rxvt_img * 765rxvt_img *
210rxvt_img::clone () 766rxvt_img::clone ()
211{ 767{
212 GC gc = XCreateGC (s->display->dpy, pm, 0, 0); 768 return new rxvt_img (*this);
213 Pixmap pm2 = XCreatePixmap (s->display->dpy, pm, w, h, format->depth);
214 XCopyArea (s->display->dpy, pm, pm2, gc, 0, 0, w, h, 0, 0);
215 XFreeGC (s->display->dpy, gc);
216 return new rxvt_img (s, format, w, h, pm2);
217} 769}
218 770
219rxvt_img * 771rxvt_img *
220rxvt_img::transform (int new_width, int new_height, int repeat, double matrix[9]) 772rxvt_img::reify ()
221{ 773{
222 //TODO 774 if (x == 0 && y == 0 && w == ref->w && h == ref->h)
775 return clone ();
776
777 // add an alpha channel if...
778 bool alpha = !format->direct.alphaMask // pixmap has none yet
779 && (x || y) // we need one because of non-zero offset
780 && repeat == RepeatNone; // and we have no good pixels to fill with
781
782 composer cc (this, new rxvt_img (d, alpha ? find_alpha_format_for (d->dpy, format) : format,
783 0, 0, w, h, repeat));
784
785 if (repeat == RepeatNone)
786 {
787 XRenderColor rc = { 0, 0, 0, 0 };
788 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
789 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
790 }
791 else
792 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
793
794 return cc;
795}
796
797rxvt_img *
798rxvt_img::sub_rect (int x, int y, int width, int height)
799{
800 rxvt_img *img = clone ();
801
802 img->x -= x;
803 img->y -= y;
804
805 if (w != width || h != height)
806 {
807 img->w = width;
808 img->h = height;
809
810 rxvt_img *img2 = img->reify ();
811 delete img;
812 img = img2;
813 }
814
815 return img;
816}
817
818rxvt_img *
819rxvt_img::transform (const nv matrix[3][3])
820{
821 return transform (mat3x3 (&matrix[0][0]));
822}
823
824rxvt_img *
825rxvt_img::transform (const nv *matrix)
826{
827 mat3x3 m (matrix);
828
829 // calculate new pixel bounding box coordinates
830 nv rmin[2], rmax[2];
831
832 for (int i = 0; i < 2; ++i)
833 {
834 nv v;
835
836 v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v;
837 v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v);
838 v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
839 v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
840 }
841
842 float sx = rmin [0] - x;
843 float sy = rmin [1] - y;
844
845 // TODO: adjust matrix for subpixel accuracy
846 int nx = floor (rmin [0]);
847 int ny = floor (rmin [1]);
848
849 int new_width = ceil (rmax [0] - rmin [0]);
850 int new_height = ceil (rmax [1] - rmin [1]);
851
852 mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
853
854 composer cc (this, new rxvt_img (d, format, nx, ny, new_width, new_height, repeat));
855
856 XTransform xfrm;
857
858 for (int i = 0; i < 3; ++i)
859 for (int j = 0; j < 3; ++j)
860 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
861
862 XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
863 XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
864 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
865
866 return cc;
223} 867}
224 868
225rxvt_img * 869rxvt_img *
226rxvt_img::scale (int new_width, int new_height) 870rxvt_img::scale (int new_width, int new_height)
227{ 871{
228 double matrix[9] = { 872 if (w == new_width && h == new_height)
229 new_width / (double)w, 0, 0, 873 return clone ();
230 0, new_height / (double)h, 0,
231 0, 0, 1
232 };
233 874
234 return transform (new_width, new_height, RepeatNormal, matrix); 875 int old_repeat_mode = repeat;
235} 876 repeat = RepeatPad; // not right, but xrender can't properly scale it seems
236 877
237rxvt_img * 878 rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
238rxvt_img::convert_to (XRenderPictFormat *new_format)
239{
240 rxvt_img *img = new rxvt_img (s, new_format, w, h);
241 879
242 Display *dpy = s->display->dpy; 880 repeat = old_repeat_mode;
243 Picture src = XRenderCreatePicture (dpy, pm, format, 0, 0); 881 img->repeat = repeat;
244 Picture dst = XRenderCreatePicture (dpy, img->pm, new_format, 0, 0);
245
246 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);
247
248 XRenderFreePicture (dpy, src);
249 XRenderFreePicture (dpy, dst);
250 882
251 return img; 883 return img;
252} 884}
253 885
886rxvt_img *
887rxvt_img::rotate (int cx, int cy, nv phi)
888{
889 move (-cx, -cy);
890 rxvt_img *img = transform (mat3x3::rotate (phi));
891 move ( cx, cy);
892 img->move (cx, cy);
893
894 return img;
895}
896
897rxvt_img *
898rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
899{
900 if (new_format == format)
901 return clone ();
902
903 composer cc (this, new rxvt_img (d, new_format, x, y, w, h, repeat));
904
905 int op = PictOpSrc;
906
907 if (format->direct.alphaMask && !new_format->direct.alphaMask)
908 {
909 // does it have to be that complicated
910 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
911 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
912
913 op = PictOpOver;
914 }
915
916 XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
917
918 return cc;
919}
920
921rxvt_img *
922rxvt_img::tint (const rgba &c)
923{
924 composer cc (this);
925 cc.mask (true);
926 cc.fill (c);
927
928 XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
929
930 return cc;
931}
932
933rxvt_img *
934rxvt_img::shade (nv factor, rgba c)
935{
936 clamp_it (factor, -1., 1.);
937 factor++;
938
939 if (factor > 1)
940 {
941 c.r = c.r * (2 - factor);
942 c.g = c.g * (2 - factor);
943 c.b = c.b * (2 - factor);
944 }
945 else
946 {
947 c.r = c.r * factor;
948 c.g = c.g * factor;
949 c.b = c.b * factor;
950 }
951
952 rxvt_img *img = this->tint (c);
953
954 if (factor > 1)
955 {
956 c.a = 0xffff;
957 c.r =
958 c.g =
959 c.b = 0xffff * (factor - 1);
960
961 img->brightness (c.r, c.g, c.b, c.a);
962 }
963
964 return img;
965}
966
967rxvt_img *
968rxvt_img::filter (const char *name, int nparams, nv *params)
969{
970 composer cc (this);
971
972 XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
973
974 for (int i = 0; i < nparams; ++i)
975 xparams [i] = XDoubleToFixed (params [i]);
976
977 XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
978
979 XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
980
981 return cc;
982}
983
254#endif 984#endif
255 985

Diff Legend

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