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.9 by root, Sun Jun 3 20:47:00 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{
18} 261}
19 262
20rxvt_img * 263rxvt_img::rxvt_img (const rxvt_img &img)
21rxvt_img::new_from_file (rxvt_screen *s, const char *filename) 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)
22{ 265{
23 GError *err; 266 ++ref->cnt;
24 GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err); 267}
25 268
26 if (!pb) 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))
27 return 0; 286 return 0;
28 287
29 rxvt_img *img = new rxvt_img ( 288 rxvt_img *img = new rxvt_img (
30 s, 289 s,
31 XRenderFindStandardFormat (s->display->dpy, gdk_pixbuf_get_has_alpha (pb) ? PictStandardARGB32 : PictStandardRGB24), 290 XRenderFindVisualFormat (dpy, DefaultVisual (dpy, s->display->screen)),
32 gdk_pixbuf_get_width (pb), 291 0,
33 gdk_pixbuf_get_height (pb) 292 0,
293 root_pm_w,
294 root_pm_h
34 ); 295 );
35 296
36 img->render (pb, 0, 0, img->w, img->h, 0, 0); 297 img->pm = root_pixmap;
298 img->ref = new pixref (root_pm_w, root_pm_h);
299 img->ref->ours = false;
37 300
38 return img; 301 return img;
39} 302}
40 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;
398}
399
400rxvt_img *
401rxvt_img::new_from_file (rxvt_screen *s, const char *filename)
402{
403 GError *err = 0;
404 GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err);
405
406 if (!pb)
407 rxvt_fatal ("rxvt_img::new_from_file: %s\n", err->message);
408
409 rxvt_img *img = new_from_pixbuf (s, pb);
410
411 g_object_unref (pb);
412
413 return img;
414}
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);
45} 433}
46 434
47void 435void
48rxvt_img::fill (const rxvt_color &c) 436rxvt_img::alloc ()
49{ 437{
50 XGCValues gcv; 438 pm = XCreatePixmap (d->dpy, d->root, w, h, format->depth);
51 gcv.foreground = c; 439 ref = new pixref (w, h);
52 GC gc = XCreateGC (s->display->dpy, pm, GCForeground, &gcv); 440}
53 XFillRectangle (s->display->dpy, pm, gc, 0, 0, w, h); 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;
461}
462
463void
464rxvt_img::unshare ()
465{
466 if (ref->cnt == 1 && ref->ours)
467 return;
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);
54 XFreeGC (s->display->dpy, gc); 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
507 rxvt_img *img = cc;
508
509 ::swap (img->ref, ref);
510 ::swap (img->pm , pm );
511
512 delete img;
55} 513}
56 514
57static void 515static void
58get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params) 516get_gaussian_kernel (int radius, int width, nv *kernel, XFixed *params)
59{ 517{
60 double sigma = radius / 2.0; 518 nv sigma = radius / 2.0;
61 double scale = sqrt (2.0 * M_PI) * sigma; 519 nv scale = sqrt (2.0 * M_PI) * sigma;
62 double sum = 0.0; 520 nv sum = 0.0;
63 521
64 for (int i = 0; i < width; i++) 522 for (int i = 0; i < width; i++)
65 { 523 {
66 double x = i - width / 2; 524 nv x = i - width / 2;
67 kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale; 525 kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;
68 sum += kernel[i]; 526 sum += kernel[i];
69 } 527 }
70 528
71 params[0] = XDoubleToFixed (width); 529 params[0] = XDoubleToFixed (width);
… …
73 531
74 for (int i = 0; i < width; i++) 532 for (int i = 0; i < width; i++)
75 params[i+2] = XDoubleToFixed (kernel[i] / sum); 533 params[i+2] = XDoubleToFixed (kernel[i] / sum);
76} 534}
77 535
78void 536rxvt_img *
79rxvt_img::blur (int rh, int rv) 537rxvt_img::blur (int rh, int rv)
80{ 538{
81 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV)) 539 if (!(d->flags & DISPLAY_HAS_RENDER_CONV))
82 return; 540 return clone ();
83 541
84 Display *dpy = s->display->dpy; 542 Display *dpy = d->dpy;
85 int size = max (rh, rv) * 2 + 1; 543 int size = max (rh, rv) * 2 + 1;
86 double *kernel = (double *)malloc (size * sizeof (double)); 544 nv *kernel = (nv *)malloc (size * sizeof (nv));
87 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 545 XFixed *params = rxvt_temp_buf<XFixed> (size + 2);
546 rxvt_img *img = new_empty ();
88 547
89 XRenderPictureAttributes pa; 548 XRenderPictureAttributes pa;
90
91 pa.repeat = RepeatPad; 549 pa.repeat = RepeatPad;
92 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
93 Pixmap tmp = XCreatePixmap (dpy, pm, w, h, format->depth); 553 Pixmap tmp_pm = XCreatePixmap (dpy, pm, w, h, format->depth);
94 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa); 554 Picture tmp = XRenderCreatePicture (dpy, tmp_pm , format, CPRepeat, &pa);
95 XFreePixmap (dpy, tmp); 555 XFreePixmap (dpy, tmp_pm);
96 556
97 if (kernel && params) 557 if (kernel && params)
98 { 558 {
99 size = rh * 2 + 1; 559 size = rh * 2 + 1;
100 get_gaussian_kernel (rh, size, kernel, params); 560 get_gaussian_kernel (rh, size, kernel, params);
101 561
102 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 562 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
103 XRenderComposite (dpy, 563 XRenderComposite (dpy,
104 PictOpSrc, 564 PictOpSrc,
105 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,
106 None, 581 None,
107 dst, 582 dst,
108 0, 0, 583 0, 0,
109 0, 0, 584 0, 0,
110 0, 0, 585 0, 0,
111 w, h); 586 w, h);
112
113 ::swap (src, dst);
114
115 size = rv * 2 + 1;
116 get_gaussian_kernel (rv, size, kernel, params);
117 ::swap (params[0], params[1]);
118
119 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
120 XRenderComposite (dpy,
121 PictOpSrc,
122 src,
123 None,
124 dst,
125 0, 0,
126 0, 0,
127 0, 0,
128 w, h);
129 } 587 }
130 588
131 free (kernel); 589 free (kernel);
132 free (params); 590
133 XRenderFreePicture (dpy, src); 591 XRenderFreePicture (dpy, src);
134 XRenderFreePicture (dpy, dst); 592 XRenderFreePicture (dpy, dst);
135} 593 XRenderFreePicture (dpy, tmp);
136 594
137static Picture
138create_xrender_mask (Display *dpy, Drawable drawable, Bool argb)
139{
140 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
141
142 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
143 XRenderPictureAttributes pa;
144 pa.repeat = True;
145 Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa);
146
147 XFreePixmap (dpy, pixmap);
148
149 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;
150} 673}
151 674
152void 675void
153rxvt_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)
154{ 677{
678 unshare ();
679
155 Display *dpy = s->display->dpy; 680 Display *dpy = d->dpy;
156 Picture src = create_xrender_mask (dpy, pm, True);
157 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 681 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
158 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;
159 XRenderColor mask_c; 687 XRenderColor mask_c;
160 mask_c.red = float_to_component (r); 688
161 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))
162 mask_c.blue = float_to_component (b);
163 mask_c.alpha = float_to_component (a);
164 XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1); 690 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
165 691
166 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);
167} 706}
168 707
169void 708void
170rxvt_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)
171{ 710{
172 if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL)) 711 if (r < 0 || g < 0 || b < 0 || a < 0)
173 return; 712 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
174 713
175 Display *dpy = s->display->dpy; 714 // premultiply (yeah, these are not exact, sue me or fix it)
176 Picture src = create_xrender_mask (dpy, pm, True); 715 r = (r * (a >> 8)) >> 8;
177 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 716 g = (g * (a >> 8)) >> 8;
717 b = (b * (a >> 8)) >> 8;
178 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;
179 XRenderColor mask_c; 729 XRenderColor mask_c;
180 mask_c.red = float_to_component (r); 730
181 mask_c.green = float_to_component (g); 731 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
182 mask_c.blue = float_to_component (b); 732 {
183 mask_c.alpha = float_to_component (a);
184 XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1); 733 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &mask_c, 0, 0, 1, 1);
185
186 XRenderComposite (dpy, PictOpMultiply, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 734 XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
735 }
736 }
737
738 ::swap (img->ref, ref);
739 ::swap (img->pm , pm );
740
741 delete img;
187} 742}
188 743
189void 744void
190rxvt_img::render (GdkPixbuf *pixbuf, int src_x, int src_y, int width, int height, int dst_x, int dst_y) 745rxvt_img::draw (rxvt_img *img, int op, nv mask)
191{ 746{
192 //TODO 747 unshare ();
193}
194 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);
755}
756
195rxvt_img * 757rxvt_img *
196rxvt_img::copy () 758rxvt_img::clone ()
197{ 759{
198 GC gc = XCreateGC (s->display->dpy, pm, 0, 0); 760 return new rxvt_img (*this);
199 Pixmap pm2 = XCreatePixmap (s->display->dpy, pm, w, h, format->depth);
200 XCopyArea (s->display->dpy, pm, pm2, gc, 0, 0, w, h, 0, 0);
201 XFreeGC (s->display->dpy, gc);
202 return new rxvt_img (s, format, w, h, pm2);
203} 761}
204 762
205rxvt_img * 763rxvt_img *
206rxvt_img::transform (int new_width, int new_height, double matrix[16]) 764rxvt_img::reify ()
207{ 765{
208 //TODO 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 *
790rxvt_img::sub_rect (int x, int y, int width, int height)
791{
792 rxvt_img *img = clone ();
793
794 img->x -= x;
795 img->y -= y;
796
797 if (w != width || h != height)
798 {
799 img->w = width;
800 img->h = height;
801
802 rxvt_img *img2 = img->reify ();
803 delete img;
804 img = img2;
805 }
806
807 return img;
808}
809
810rxvt_img *
811rxvt_img::transform (const nv matrix[3][3])
812{
813 return transform (mat3x3 (&matrix[0][0]));
814}
815
816rxvt_img *
817rxvt_img::transform (const nv *matrix)
818{
819 mat3x3 m (matrix);
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));
847
848 XTransform xfrm;
849
850 for (int i = 0; i < 3; ++i)
851 for (int j = 0; j < 3; ++j)
852 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
853
854 XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
855 XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
856 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
857
858 return cc;
209} 859}
210 860
211rxvt_img * 861rxvt_img *
212rxvt_img::scale (int new_width, int new_height) 862rxvt_img::scale (int new_width, int new_height)
213{ 863{
214 // use transform 864 if (w == new_width && h == new_height)
215 //TODO 865 return clone ();
216}
217 866
218rxvt_img * 867 int old_repeat_mode = repeat;
219rxvt_img::convert_to (XRenderPictFormat *new_format) 868 repeat = RepeatPad; // not right, but xrender can't properly scale it seems
220{
221 rxvt_img *img = new rxvt_img (s,new_format,w, h);
222 869
223 Display *dpy = s->display->dpy; 870 rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
224 Picture src = XRenderCreatePicture (dpy, pm, format, 0, 0);
225 Picture dst = XRenderCreatePicture (dpy, img->pm, new_format, 0, 0);
226 871
227 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 872 repeat = old_repeat_mode;
228 873 img->repeat = repeat;
229 XRenderFreePicture (dpy, src);
230 XRenderFreePicture (dpy, dst);
231 874
232 return img; 875 return img;
233} 876}
234 877
878rxvt_img *
879rxvt_img::rotate (int cx, int cy, nv phi)
880{
881 move (-cx, -cy);
882 rxvt_img *img = transform (mat3x3::rotate (phi));
883 move ( cx, cy);
884 img->move (cx, cy);
885
886 return img;
887}
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
235#endif 976#endif
236 977

Diff Legend

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