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.114 by sf-exg, Wed Jan 10 06:06:16 2024 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_pixbuf (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 rxvt_img *img = new rxvt_img (d, format, 0, 0, w * 2, h, repeat);
612 composer cc (this, img);
613
614 // why the hell does XRenderSetPictureTransform want a writable matrix :(
615 // that keeps us from just static const'ing this matrix.
616 XTransform h_double = {
617 0x08000, 0, 0,
618 0, 0x10000, 0,
619 0, 0, 0x10000
620 };
621
622 XRenderSetPictureFilter (cc.dpy, cc.src, "nearest", 0, 0);
623 XRenderSetPictureTransform (cc.dpy, cc.src, &h_double);
624 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
625
626 cc.mask (false, 2, 1);
627
628 static const XRenderColor c0 = { 0, 0, 0, 0 };
629 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c0, 0, 0, 1, 1);
630 static const XRenderColor c1 = { 65535, 65535, 65535, 65535 };
631 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c1, 1, 0, 1, 1);
632
633 Picture white = XRenderCreateSolidFill (cc.dpy, &c1);
634
635 XRenderComposite (cc.dpy, PictOpOver, white, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
636
637 XRenderFreePicture (cc.dpy, white);
638
639 // STEP 2: convolve the image with a 3x1 filter
640 // a 2x1 filter would obviously suffice, but given the total lack of specification
641 // for xrender, I expect different xrender implementations to randomly diverge.
642 // we also halve the image, and hope for the best (again, for lack of specs).
643 composer cc2 (img);
644
645 XFixed kernel [] = {
646 XDoubleToFixed (3), XDoubleToFixed (1),
647 XDoubleToFixed (0), XDoubleToFixed (mul), XDoubleToFixed (add)
648 };
649
650 XTransform h_halve = {
651 0x20000, 0, 0,
652 0, 0x10000, 0,
653 0, 0, 0x10000
654 };
655
656 XRenderSetPictureFilter (cc.dpy, cc2.src, "nearest", 0, 0);
657 XRenderSetPictureTransform (cc.dpy, cc2.src, &h_halve);
658 XRenderSetPictureFilter (cc.dpy, cc2.src, FilterConvolution, kernel, ecb_array_length (kernel));
659
660 XRenderComposite (cc.dpy, PictOpSrc, cc2.src, None, cc2.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
661
662 delete img;
663
664 return cc2;
665}
666
667ecb_noinline static void
668extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
669{
670 int32_t x = clamp (c, cl0, cl1);
671 c -= x;
672 xc = x;
673}
674
675ecb_noinline static bool
676extract (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)
677{
678 extract (cl0, cl1, r, xr);
679 extract (cl0, cl1, g, xg);
680 extract (cl0, cl1, b, xb);
681 extract (cl0, cl1, a, xa);
682
683 return xr | xg | xb | xa;
164} 684}
165 685
166void 686void
167rxvt_img::brightness (double r, double g, double b, double a) 687rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
168{ 688{
689 unshare ();
690
169 Display *dpy = s->display->dpy; 691 Display *dpy = d->dpy;
170 Picture src = create_xrender_mask (dpy, pm, True);
171 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 692 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
172 693
694 // loop should not be needed for brightness, as only -1..1 makes sense
695 //while (r | g | b | a)
696 {
173 XRenderColor mask_c; 697 XRenderColor mask_c;
174 mask_c.red = float_to_component (r); 698
175 mask_c.green = float_to_component (g); 699 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); 700 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
179 701
180 XRenderComposite (dpy, PictOpAdd, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 702 if (extract (-65535, 0, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
703 {
704 XRenderColor mask_w = { 65535, 65535, 65535, 65535 };
705 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
706 mask_c.red = -mask_c.red; //TODO: verify that doing clamp, assign, and negation does the right thing
707 mask_c.green = -mask_c.green;
708 mask_c.blue = -mask_c.blue;
709 mask_c.alpha = -mask_c.alpha;
710 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
711 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
712 }
713 }
714
715 XRenderFreePicture (dpy, dst);
181} 716}
182 717
183void 718void
184rxvt_img::contrast (double r, double g, double b, double a) 719rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
185{ 720{
186 if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL)) 721 if (r < 0 || g < 0 || b < 0 || a < 0)
187 return; 722 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
188 723
189 Display *dpy = s->display->dpy; 724 // premultiply (yeah, these are not exact, sue me or fix it)
190 Picture src = create_xrender_mask (dpy, pm, True); 725 r = (r * (a >> 8)) >> 8;
191 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 726 g = (g * (a >> 8)) >> 8;
727 b = (b * (a >> 8)) >> 8;
192 728
729 composer cc (this);
730 rxvt_img *img = cc;
731 img->fill (rgba (0, 0, 0, 0));
732
733 cc.mask (true);
734
735 //TODO: this operator does not yet implement some useful contrast
736 while (r | g | b | a)
737 {
193 XRenderColor mask_c; 738 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 739
200 XRenderComposite (dpy, PictOpMultiply, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 740 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 { 741 {
271 unsigned char *pixel = row + x * channels; 742 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &mask_c, 0, 0, 1, 1);
272 uint32_t value; 743 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 } 744 }
300
301 row += rowstride;
302 line += ximage->bytes_per_line;
303 } 745 }
304 746
305 XPutImage (dpy, pm, gc, ximage, 0, 0, dst_x, dst_y, width, height); 747 ::swap (img->ref, ref);
306 XDestroyImage (ximage); 748 ::swap (img->pm , pm );
307 XFreeGC (dpy, gc);
308 749
309 return true; 750 delete img;
751}
752
753void
754rxvt_img::draw (rxvt_img *img, int op, nv mask)
755{
756 unshare ();
757
758 composer cc (img, this);
759
760 if (mask != 1.)
761 cc.mask (rgba (0, 0, 0, float_to_component (mask)));
762
763 XRenderComposite (cc.dpy, op, cc.src, cc.msk, cc.dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h);
310} 764}
311 765
312rxvt_img * 766rxvt_img *
313rxvt_img::clone () 767rxvt_img::clone ()
314{ 768{
315 rxvt_img *img = new rxvt_img (s, format, w, h); 769 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} 770}
321 771
322rxvt_img * 772rxvt_img *
773rxvt_img::reify ()
774{
775 if (x == 0 && y == 0 && w == ref->w && h == ref->h)
776 return clone ();
777
778 // add an alpha channel if...
779 bool alpha = !format->direct.alphaMask // pixmap has none yet
780 && (x || y) // we need one because of non-zero offset
781 && repeat == RepeatNone; // and we have no good pixels to fill with
782
783 composer cc (this, new rxvt_img (d, alpha ? find_alpha_format_for (d->dpy, format) : format,
784 0, 0, w, h, repeat));
785
786 if (repeat == RepeatNone)
787 {
788 XRenderColor rc = { 0, 0, 0, 0 };
789 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
790 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
791 }
792 else
793 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
794
795 return cc;
796}
797
798rxvt_img *
323rxvt_img::sub_rect (int x, int y, int width, int height, int repeat) 799rxvt_img::sub_rect (int x, int y, int width, int height)
324{ 800{
325 rxvt_img *img = new rxvt_img (s, format, width, height); 801 rxvt_img *img = clone ();
326 802
327 Display *dpy = s->display->dpy; 803 img->x -= x;
328 XRenderPictureAttributes pa; 804 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 805
333 XRenderComposite (dpy, PictOpSrc, src, None, dst, x, y, 0, 0, 0, 0, width, height); 806 if (w != width || h != height)
807 {
808 img->w = width;
809 img->h = height;
334 810
335 XRenderFreePicture (dpy, src); 811 rxvt_img *img2 = img->reify ();
336 XRenderFreePicture (dpy, dst); 812 delete img;
813 img = img2;
814 }
337 815
338 return img; 816 return img;
339} 817}
340 818
341rxvt_img * 819rxvt_img *
342rxvt_img::transform (int new_width, int new_height, double matrix[9], int repeat) 820rxvt_img::transform (const nv matrix[3][3])
343{ 821{
344 rxvt_img *img = new rxvt_img (s, format, new_width, new_height); 822 return transform (mat3x3 (&matrix[0][0]));
823}
345 824
346 Display *dpy = s->display->dpy; 825rxvt_img *
347 XRenderPictureAttributes pa; 826rxvt_img::transform (const nv *matrix)
348 pa.repeat = repeat; 827{
349 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 828 mat3x3 m (matrix);
350 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0); 829
830 // calculate new pixel bounding box coordinates
831 nv rmin[2], rmax[2];
832
833 for (int i = 0; i < 2; ++i)
834 {
835 nv v;
836
837 v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v;
838 v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v);
839 v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
840 v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
841 }
842
843 float sx = rmin [0] - x;
844 float sy = rmin [1] - y;
845
846 // TODO: adjust matrix for subpixel accuracy
847 int nx = floor (rmin [0]);
848 int ny = floor (rmin [1]);
849
850 int new_width = ceil (rmax [0] - rmin [0]);
851 int new_height = ceil (rmax [1] - rmin [1]);
852
853 mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
854
855 composer cc (this, new rxvt_img (d, format, nx, ny, new_width, new_height, repeat));
351 856
352 XTransform xfrm; 857 XTransform xfrm;
353 858
354 for (int i = 0; i < 3; ++i) 859 for (int i = 0; i < 3; ++i)
355 for (int j = 0; j < 3; ++j) 860 for (int j = 0; j < 3; ++j)
356 xfrm.matrix [i][j] = XDoubleToFixed (matrix [i * 3 + j]); 861 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
357 862
358 XRenderSetPictureFilter (dpy, src, "good", 0, 0); 863 XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
359 XRenderSetPictureTransform (dpy, src, &xfrm); 864 XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
360 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, new_width, new_height); 865 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
361 866
362 XRenderFreePicture (dpy, src); 867 return cc;
363 XRenderFreePicture (dpy, dst); 868}
869
870rxvt_img *
871rxvt_img::scale (int new_width, int new_height)
872{
873 if (w == new_width && h == new_height)
874 return clone ();
875
876 int old_repeat_mode = repeat;
877 repeat = RepeatPad; // not right, but xrender can't properly scale it seems
878
879 rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
880
881 repeat = old_repeat_mode;
882 img->repeat = repeat;
364 883
365 return img; 884 return img;
366} 885}
367 886
368rxvt_img * 887rxvt_img *
369rxvt_img::scale (int new_width, int new_height) 888rxvt_img::rotate (int cx, int cy, nv phi)
370{ 889{
371 double matrix[9] = { 890 move (-cx, -cy);
372 w / (double)new_width, 0, 0, 891 rxvt_img *img = transform (mat3x3::rotate (phi));
373 0, h / (double)new_height, 0, 892 move ( cx, cy);
374 0, 0, 1 893 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 894
409 return img; 895 return img;
410} 896}
411 897
898rxvt_img *
899rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
900{
901 if (new_format == format)
902 return clone ();
903
904 composer cc (this, new rxvt_img (d, new_format, x, y, w, h, repeat));
905
906 int op = PictOpSrc;
907
908 if (format->direct.alphaMask && !new_format->direct.alphaMask)
909 {
910 // does it have to be that complicated
911 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
912 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
913
914 op = PictOpOver;
915 }
916
917 XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
918
919 return cc;
920}
921
922rxvt_img *
923rxvt_img::tint (const rgba &c)
924{
925 composer cc (this);
926 cc.mask (true);
927 cc.fill (c);
928
929 XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
930
931 return cc;
932}
933
934rxvt_img *
935rxvt_img::shade (nv factor, rgba c)
936{
937 clamp_it (factor, -1., 1.);
938 factor++;
939
940 if (factor > 1)
941 {
942 c.r = c.r * (2 - factor);
943 c.g = c.g * (2 - factor);
944 c.b = c.b * (2 - factor);
945 }
946 else
947 {
948 c.r = c.r * factor;
949 c.g = c.g * factor;
950 c.b = c.b * factor;
951 }
952
953 rxvt_img *img = this->tint (c);
954
955 if (factor > 1)
956 {
957 c.a = 0xffff;
958 c.r =
959 c.g =
960 c.b = 0xffff * (factor - 1);
961
962 img->brightness (c.r, c.g, c.b, c.a);
963 }
964
965 return img;
966}
967
968rxvt_img *
969rxvt_img::filter (const char *name, int nparams, nv *params)
970{
971 composer cc (this);
972
973 XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
974
975 for (int i = 0; i < nparams; ++i)
976 xparams [i] = XDoubleToFixed (params [i]);
977
978 XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
979
980 XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
981
982 return cc;
983}
984
412#endif 985#endif
413 986

Diff Legend

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