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.10 by sf-exg, Mon Jun 4 06:59:50 2012 UTC vs.
Revision 1.104 by root, Sat Jul 14 08:27:55 2012 UTC

1/*----------------------------------------------------------------------*
2 * File: rxvtimg.C
3 *----------------------------------------------------------------------*
4 *
5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2012 Marc Lehmann <schmorp@schmorp.de>
7 * Copyright (c) 2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 *---------------------------------------------------------------------*/
23
24#include <string.h>
1#include <math.h> 25#include <math.h>
2#include "../config.h" 26#include "../config.h"
3#include "rxvt.h" 27#include "rxvt.h"
4 28
5#if HAVE_IMG 29#if HAVE_IMG
6 30
7#define float_to_component(d) ((d) * 65535.99) 31typedef rxvt_img::nv nv;
8 32
33namespace
34{
35 struct mat3x3
36 {
37 nv v[3][3];
38
39 mat3x3 ()
40 {
41 }
42
43 mat3x3 (const nv *matrix)
44 {
45 memcpy (v, matrix, sizeof (v));
46 }
47
48 mat3x3 (nv v11, nv v12, nv v13, nv v21, nv v22, nv v23, nv v31, nv v32, nv v33)
49 {
50 v[0][0] = v11; v[0][1] = v12; v[0][2] = v13;
51 v[1][0] = v21; v[1][1] = v22; v[1][2] = v23;
52 v[2][0] = v31; v[2][1] = v32; v[2][2] = v33;
53 }
54
55 mat3x3 inverse ();
56
57 nv *operator [](int i) { return &v[i][0]; }
58 const nv *operator [](int i) const { return &v[i][0]; }
59
60 operator const nv * () const { return &v[0][0]; }
61 operator nv * () { return &v[0][0]; }
62
63 // quite inefficient, hopefully gcc pulls the w calc out of any loops
64 nv apply1 (int i, nv x, nv y)
65 {
66 mat3x3 &m = *this;
67
68 nv v = m[i][0] * x + m[i][1] * y + m[i][2];
69 nv w = m[2][0] * x + m[2][1] * y + m[2][2];
70
71 return v * (1. / w);
72 }
73
74 static mat3x3 translate (nv x, nv y);
75 static mat3x3 scale (nv s, nv t);
76 static mat3x3 rotate (nv phi);
77 };
78
79 mat3x3
80 mat3x3::inverse ()
81 {
82 mat3x3 &m = *this;
83 mat3x3 inv;
84
85 nv s0 = m[2][2] * m[1][1] - m[2][1] * m[1][2];
86 nv s1 = m[2][1] * m[0][2] - m[2][2] * m[0][1];
87 nv s2 = m[1][2] * m[0][1] - m[1][1] * m[0][2];
88
89 nv invdet = 1. / (m[0][0] * s0 + m[1][0] * s1 + m[2][0] * s2);
90
91 inv[0][0] = invdet * s0;
92 inv[0][1] = invdet * s1;
93 inv[0][2] = invdet * s2;
94
95 inv[1][0] = invdet * (m[2][0] * m[1][2] - m[2][2] * m[1][0]);
96 inv[1][1] = invdet * (m[2][2] * m[0][0] - m[2][0] * m[0][2]);
97 inv[1][2] = invdet * (m[1][0] * m[0][2] - m[1][2] * m[0][0]);
98
99 inv[2][0] = invdet * (m[2][1] * m[1][0] - m[2][0] * m[1][1]);
100 inv[2][1] = invdet * (m[2][0] * m[0][1] - m[2][1] * m[0][0]);
101 inv[2][2] = invdet * (m[1][1] * m[0][0] - m[1][0] * m[0][1]);
102
103 return inv;
104 }
105
106 static mat3x3
107 operator *(const mat3x3 &a, const mat3x3 &b)
108 {
109 mat3x3 r;
110
111 for (int i = 0; i < 3; ++i)
112 for (int j = 0; j < 3; ++j)
113 r[i][j] = a[i][0] * b[0][j]
114 + a[i][1] * b[1][j]
115 + a[i][2] * b[2][j];
116
117 return r;
118 }
119
120 mat3x3
121 mat3x3::translate (nv x, nv y)
122 {
123 return mat3x3 (
124 1, 0, x,
125 0, 1, y,
126 0, 0, 1
127 );
128 }
129
130 mat3x3
131 mat3x3::scale (nv s, nv t)
132 {
133 return mat3x3 (
134 s, 0, 0,
135 0, t, 0,
136 0, 0, 1
137 );
138 }
139
140 // clockwise
141 mat3x3
142 mat3x3::rotate (nv phi)
143 {
144 nv s = sin (phi);
145 nv c = cos (phi);
146
147 return mat3x3 (
148 c, -s, 0,
149 s, c, 0,
150 0, 0, 1
151 );
152 }
153
154 struct composer
155 {
156 rxvt_img *srcimg, *dstimg;
157 Picture src, dst, msk;
158 Display *dpy;
159
160 ecb_noinline
161 composer (rxvt_img *srcimg, rxvt_img *dstimg = 0)
162 : srcimg (srcimg), dstimg (dstimg), msk (0)
163 {
164 if (!this->dstimg)
165 this->dstimg = srcimg->new_empty ();
166 else if (!this->dstimg->pm) // somewhat unsatisfying
167 this->dstimg->alloc ();
168
169 dpy = srcimg->s->dpy;
170 src = srcimg->picture ();
171 dst = this->dstimg->picture ();
172 }
173
174 ecb_noinline
175 void mask (bool rgb = true, int w = 1, int h = 1)
176 {
177 Pixmap pixmap = XCreatePixmap (dpy, srcimg->pm, w, h, rgb ? 32 : 8);
178
179 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, rgb ? PictStandardARGB32 : PictStandardA8);
180 XRenderPictureAttributes pa;
181 pa.repeat = RepeatNormal;
182 pa.component_alpha = rgb;
183 msk = XRenderCreatePicture (dpy, pixmap, format, CPRepeat | CPComponentAlpha, &pa);
184
185 XFreePixmap (dpy, pixmap);
186
187 ecb_assume (msk);
188 }
189
190 // CreateSolidFill creates a very very very weird picture
191 void mask (const rgba &c)
192 {
193 XRenderColor rc = {
194 c.r * c.a / 65535,
195 c.g * c.a / 65535,
196 c.b * c.a / 65535,
197 c.a
198 };
199 msk = XRenderCreateSolidFill (dpy, &rc);
200 ecb_assume (msk);
201 }
202
203 void fill (const rgba &c)
204 {
205 XRenderColor rc = {
206 c.r * c.a / 65535,
207 c.g * c.a / 65535,
208 c.b * c.a / 65535,
209 c.a
210 };
211
212 XRenderFillRectangle (dpy, PictOpSrc, msk, &rc, 0, 0, 1, 1);
213 }
214
215 operator rxvt_img *()
216 {
217 return dstimg;
218 }
219
220 ecb_noinline
221 ~composer ()
222 {
223 XRenderFreePicture (dpy, src);
224 XRenderFreePicture (dpy, dst);
225 if (msk) XRenderFreePicture (dpy, msk);
226 }
227 };
228}
229
230static XRenderPictFormat *
231find_alpha_format_for (Display *dpy, XRenderPictFormat *format)
232{
233 if (format->direct.alphaMask)
234 return format; // already has alpha
235
236 // try to find a suitable alpha format, one bit alpha is enough for our purposes
237 if (format->type == PictTypeDirect)
238 for (int n = 0; XRenderPictFormat *f = XRenderFindFormat (dpy, 0, 0, n); ++n)
239 if (f->direct.alphaMask
240 && f->type == PictTypeDirect
241 && ecb_popcount32 (f->direct.redMask ) >= ecb_popcount32 (format->direct.redMask )
242 && ecb_popcount32 (f->direct.greenMask) >= ecb_popcount32 (format->direct.greenMask)
243 && ecb_popcount32 (f->direct.blueMask ) >= ecb_popcount32 (format->direct.blueMask ))
244 return f;
245
246 // should be a very good fallback
247 return XRenderFindStandardFormat (dpy, PictStandardARGB32);
248}
249
9rxvt_img::rxvt_img (rxvt_screen *screen, XRenderPictFormat *format, int width, int height) 250rxvt_img::rxvt_img (rxvt_screen *screen, XRenderPictFormat *format, int x, int y, int width, int height, int repeat)
10: s(screen), w(width), h(height), format(format), shared(false)
11{
12 pm = XCreatePixmap (s->display->dpy, s->display->root, w, h, format->depth);
13}
14
15rxvt_img::rxvt_img (rxvt_screen *screen, XRenderPictFormat *format, int width, int height, Pixmap pixmap)
16: s(screen), pm(pixmap), w(width), h(height), format(format), shared(false) 251: s(screen), x(x), y(y), w(width), h(height), format(format), repeat(repeat),
252 pm(0), ref(0)
17{ 253{
18} 254}
19 255
20rxvt_img * 256rxvt_img::rxvt_img (const rxvt_img &img)
21rxvt_img::new_from_file (rxvt_screen *s, const char *filename) 257: s(img.s), x(img.x), y(img.y), w(img.w), h(img.h), format(img.format), repeat(img.repeat), pm(img.pm), ref(img.ref)
22{ 258{
23 GError *err; 259 ++ref->cnt;
24 GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err); 260}
25 261
26 if (!pb) 262rxvt_img *
263rxvt_img::new_from_root (rxvt_screen *s)
264{
265 Display *dpy = s->dpy;
266 unsigned int root_pm_w, root_pm_h;
267 Pixmap root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_XROOTPMAP_ID]);
268 if (root_pixmap == None)
269 root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_ESETROOT_PMAP_ID]);
270
271 if (root_pixmap == None)
272 return 0;
273
274 Window wdummy;
275 int idummy;
276 unsigned int udummy;
277
278 if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pm_w, &root_pm_h, &udummy, &udummy))
27 return 0; 279 return 0;
28 280
29 rxvt_img *img = new rxvt_img ( 281 rxvt_img *img = new rxvt_img (
30 s, 282 s,
31 XRenderFindStandardFormat (s->display->dpy, gdk_pixbuf_get_has_alpha (pb) ? PictStandardARGB32 : PictStandardRGB24), 283 XRenderFindVisualFormat (dpy, DefaultVisual (dpy, s->display->screen)),
32 gdk_pixbuf_get_width (pb), 284 0,
33 gdk_pixbuf_get_height (pb) 285 0,
286 root_pm_w,
287 root_pm_h
34 ); 288 );
35 289
36 img->render (pb, 0, 0, img->w, img->h, 0, 0); 290 img->pm = root_pixmap;
291 img->ref = new pixref (root_pm_w, root_pm_h);
292 img->ref->ours = false;
37 293
38 return img; 294 return img;
39} 295}
40 296
297# if HAVE_PIXBUF
298
299rxvt_img *
300rxvt_img::new_from_pixbuf (rxvt_screen *s, GdkPixbuf *pb)
301{
302 Display *dpy = s->dpy;
303
304 int width = gdk_pixbuf_get_width (pb);
305 int height = gdk_pixbuf_get_height (pb);
306
307 if (width > 32767 || height > 32767) // well, we *could* upload in chunks
308 rxvt_fatal ("rxvt_img::new_from_pixbuf: image too big (maximum size 32768x32768).\n");
309
310 // since we require rgb24/argb32 formats from xrender we assume
311 // that both 24 and 32 bpp MUST be supported by any screen that supports xrender
312
313 int byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
314
315 XImage xi;
316
317 xi.width = width;
318 xi.height = height;
319 xi.xoffset = 0;
320 xi.format = ZPixmap;
321 xi.byte_order = ImageByteOrder (dpy);
322 xi.bitmap_unit = 0; //XY only, unused
323 xi.bitmap_bit_order = 0; //XY only, unused
324 xi.bitmap_pad = BitmapPad (dpy);
325 xi.depth = 32;
326 xi.bytes_per_line = 0;
327 xi.bits_per_pixel = 32; //Z only
328 xi.red_mask = 0x00000000; //Z only, unused
329 xi.green_mask = 0x00000000; //Z only, unused
330 xi.blue_mask = 0x00000000; //Z only, unused
331 xi.obdata = 0; // probably unused
332
333 bool byte_order_mismatch = byte_order != xi.byte_order;
334
335 if (!XInitImage (&xi))
336 rxvt_fatal ("unable to initialise ximage, please report.\n");
337
338 if (height > INT_MAX / xi.bytes_per_line)
339 rxvt_fatal ("rxvt_img::new_from_pixbuf: image too big for Xlib.\n");
340
341 xi.data = (char *)rxvt_malloc (height * xi.bytes_per_line);
342
343 int rowstride = gdk_pixbuf_get_rowstride (pb);
344 bool pb_has_alpha = gdk_pixbuf_get_has_alpha (pb);
345 unsigned char *row = gdk_pixbuf_get_pixels (pb);
346
347 char *line = xi.data;
348
349 for (int y = 0; y < height; y++)
350 {
351 unsigned char *src = row;
352 uint32_t *dst = (uint32_t *)line;
353
354 for (int x = 0; x < width; x++)
355 {
356 uint8_t r = *src++;
357 uint8_t g = *src++;
358 uint8_t b = *src++;
359 uint8_t a = *src;
360
361 // this is done so it can be jump-free, but newer gcc's clone inner the loop
362 a = pb_has_alpha ? a : 255;
363 src += pb_has_alpha;
364
365 r = (r * a + 127) / 255;
366 g = (g * a + 127) / 255;
367 b = (b * a + 127) / 255;
368
369 uint32_t v = (a << 24) | (r << 16) | (g << 8) | b;
370
371 if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch)
372 v = ecb_bswap32 (v);
373
374 *dst++ = v;
375 }
376
377 row += rowstride;
378 line += xi.bytes_per_line;
379 }
380
381 rxvt_img *img = new rxvt_img (s, XRenderFindStandardFormat (dpy, PictStandardARGB32), 0, 0, width, height);
382 img->alloc ();
383
384 GC gc = XCreateGC (dpy, img->pm, 0, 0);
385 XPutImage (dpy, img->pm, gc, &xi, 0, 0, 0, 0, width, height);
386 XFreeGC (dpy, gc);
387
388 free (xi.data);
389
390 return img;
391}
392
393rxvt_img *
394rxvt_img::new_from_file (rxvt_screen *s, const char *filename)
395{
396 GError *err = 0;
397 GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err);
398
399 if (!pb)
400 rxvt_fatal ("rxvt_img::new_from_file: %s\n", err->message);
401
402 rxvt_img *img = new_from_pixbuf (s, pb);
403
404 g_object_unref (pb);
405
406 return img;
407}
408
409# endif
410
411void
412rxvt_img::destroy ()
413{
414 if (--ref->cnt)
415 return;
416
417 if (pm && ref->ours)
418 XFreePixmap (s->dpy, pm);
419
420 delete ref;
421}
422
41rxvt_img::~rxvt_img () 423rxvt_img::~rxvt_img ()
42{ 424{
43 if (!shared) 425 destroy ();
44 XFreePixmap (s->display->dpy, pm);
45} 426}
46 427
47void 428void
48rxvt_img::fill (const rxvt_color &c) 429rxvt_img::alloc ()
49{ 430{
50 XGCValues gcv; 431 pm = XCreatePixmap (s->dpy, s->display->root, w, h, format->depth);
51 gcv.foreground = c; 432 ref = new pixref (w, h);
52 GC gc = XCreateGC (s->display->dpy, pm, GCForeground, &gcv); 433}
53 XFillRectangle (s->display->dpy, pm, gc, 0, 0, w, h); 434
435rxvt_img *
436rxvt_img::new_empty ()
437{
438 rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat);
439 img->alloc ();
440
441 return img;
442}
443
444Picture
445rxvt_img::picture ()
446{
447 Display *dpy = s->dpy;
448
449 XRenderPictureAttributes pa;
450 pa.repeat = repeat;
451 Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
452
453 return pic;
454}
455
456void
457rxvt_img::unshare ()
458{
459 if (ref->cnt == 1 && ref->ours)
460 return;
461
462 Pixmap pm2 = XCreatePixmap (s->dpy, s->display->root, ref->w, ref->h, format->depth);
463 GC gc = XCreateGC (s->dpy, pm, 0, 0);
464 XCopyArea (s->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);
54 XFreeGC (s->display->dpy, gc); 465 XFreeGC (s->dpy, gc);
466
467 destroy ();
468
469 pm = pm2;
470 ref = new pixref (ref->w, ref->h);
471}
472
473void
474rxvt_img::fill (const rgba &c, int x, int y, int w, int h)
475{
476 XRenderColor rc = { c.r, c.g, c.b, c.a };
477
478 Display *dpy = s->dpy;
479 Picture src = picture ();
480 XRenderFillRectangle (dpy, PictOpSrc, src, &rc, x, y, w, h);
481 XRenderFreePicture (dpy, src);
482}
483
484void
485rxvt_img::fill (const rgba &c)
486{
487 fill (c, 0, 0, w, h);
488}
489
490void
491rxvt_img::add_alpha ()
492{
493 if (format->direct.alphaMask)
494 return;
495
496 composer cc (this, new rxvt_img (s, find_alpha_format_for (s->dpy, format), x, y, w, h, repeat));
497
498 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
499
500 rxvt_img *img = cc;
501
502 ::swap (img->ref, ref);
503 ::swap (img->pm , pm );
504
505 delete img;
55} 506}
56 507
57static void 508static void
58get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params) 509get_gaussian_kernel (int radius, int width, nv *kernel, XFixed *params)
59{ 510{
60 double sigma = radius / 2.0; 511 nv sigma = radius / 2.0;
61 double scale = sqrt (2.0 * M_PI) * sigma; 512 nv scale = sqrt (2.0 * M_PI) * sigma;
62 double sum = 0.0; 513 nv sum = 0.0;
63 514
64 for (int i = 0; i < width; i++) 515 for (int i = 0; i < width; i++)
65 { 516 {
66 double x = i - width / 2; 517 nv x = i - width / 2;
67 kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale; 518 kernel[i] = exp (-(x * x) / (2.0 * sigma * sigma)) / scale;
68 sum += kernel[i]; 519 sum += kernel[i];
69 } 520 }
70 521
71 params[0] = XDoubleToFixed (width); 522 params[0] = XDoubleToFixed (width);
… …
73 524
74 for (int i = 0; i < width; i++) 525 for (int i = 0; i < width; i++)
75 params[i+2] = XDoubleToFixed (kernel[i] / sum); 526 params[i+2] = XDoubleToFixed (kernel[i] / sum);
76} 527}
77 528
78void 529rxvt_img *
79rxvt_img::blur (int rh, int rv) 530rxvt_img::blur (int rh, int rv)
80{ 531{
81 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV)) 532 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))
82 return; 533 return clone ();
83 534
84 Display *dpy = s->display->dpy; 535 Display *dpy = s->dpy;
85 int size = max (rh, rv) * 2 + 1; 536 int size = max (rh, rv) * 2 + 1;
86 double *kernel = (double *)malloc (size * sizeof (double)); 537 nv *kernel = (nv *)malloc (size * sizeof (nv));
87 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 538 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
539 rxvt_img *img = new_empty ();
88 540
89 XRenderPictureAttributes pa; 541 XRenderPictureAttributes pa;
90
91 pa.repeat = RepeatPad; 542 pa.repeat = RepeatPad;
92 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 543 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
544 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
545
93 Pixmap tmp = XCreatePixmap (dpy, pm, w, h, format->depth); 546 Pixmap tmp_pm = XCreatePixmap (dpy, pm, w, h, format->depth);
94 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa); 547 Picture tmp = XRenderCreatePicture (dpy, tmp_pm , format, CPRepeat, &pa);
95 XFreePixmap (dpy, tmp); 548 XFreePixmap (dpy, tmp_pm);
96 549
97 if (kernel && params) 550 if (kernel && params)
98 { 551 {
99 size = rh * 2 + 1; 552 size = rh * 2 + 1;
100 get_gaussian_kernel (rh, size, kernel, params); 553 get_gaussian_kernel (rh, size, kernel, params);
101 554
102 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 555 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
103 XRenderComposite (dpy, 556 XRenderComposite (dpy,
104 PictOpSrc, 557 PictOpSrc,
105 src, 558 src,
559 None,
560 tmp,
561 0, 0,
562 0, 0,
563 0, 0,
564 w, h);
565
566 size = rv * 2 + 1;
567 get_gaussian_kernel (rv, size, kernel, params);
568 ::swap (params[0], params[1]);
569
570 XRenderSetPictureFilter (dpy, tmp, FilterConvolution, params, size+2);
571 XRenderComposite (dpy,
572 PictOpSrc,
573 tmp,
106 None, 574 None,
107 dst, 575 dst,
108 0, 0, 576 0, 0,
109 0, 0, 577 0, 0,
110 0, 0, 578 0, 0,
111 w, h); 579 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 } 580 }
130 581
131 free (kernel); 582 free (kernel);
132 free (params); 583 free (params);
584
133 XRenderFreePicture (dpy, src); 585 XRenderFreePicture (dpy, src);
134 XRenderFreePicture (dpy, dst); 586 XRenderFreePicture (dpy, dst);
135} 587 XRenderFreePicture (dpy, tmp);
136 588
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; 589 return img;
590}
591
592rxvt_img *
593rxvt_img::muladd (nv mul, nv add)
594{
595 // STEP 1: double the image width, fill all odd columns with white (==1)
596
597 composer cc (this, new rxvt_img (s, format, 0, 0, w * 2, h, repeat));
598
599 // why the hell does XRenderSetPictureTransform want a writable matrix :(
600 // that keeps us from just static const'ing this matrix.
601 XTransform h_double = {
602 0x08000, 0, 0,
603 0, 0x10000, 0,
604 0, 0, 0x10000
605 };
606
607 XRenderSetPictureFilter (cc.dpy, cc.src, "nearest", 0, 0);
608 XRenderSetPictureTransform (cc.dpy, cc.src, &h_double);
609 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
610
611 cc.mask (false, 2, 1);
612
613 static const XRenderColor c0 = { 0, 0, 0, 0 };
614 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c0, 0, 0, 1, 1);
615 static const XRenderColor c1 = { 65535, 65535, 65535, 65535 };
616 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c1, 1, 0, 1, 1);
617
618 Picture white = XRenderCreateSolidFill (cc.dpy, &c1);
619
620 XRenderComposite (cc.dpy, PictOpOver, white, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
621
622 XRenderFreePicture (cc.dpy, white);
623
624 // STEP 2: convolve the image with a 3x1 filter
625 // a 2x1 filter would obviously suffice, but given the total lack of specification
626 // for xrender, I expect different xrender implementations to randomly diverge.
627 // we also halve the image, and hope for the best (again, for lack of specs).
628 composer cc2 (cc.dstimg);
629
630 XFixed kernel [] = {
631 XDoubleToFixed (3), XDoubleToFixed (1),
632 XDoubleToFixed (0), XDoubleToFixed (mul), XDoubleToFixed (add)
633 };
634
635 XTransform h_halve = {
636 0x20000, 0, 0,
637 0, 0x10000, 0,
638 0, 0, 0x10000
639 };
640
641 XRenderSetPictureFilter (cc.dpy, cc2.src, "nearest", 0, 0);
642 XRenderSetPictureTransform (cc.dpy, cc2.src, &h_halve);
643 XRenderSetPictureFilter (cc.dpy, cc2.src, FilterConvolution, kernel, ecb_array_length (kernel));
644
645 XRenderComposite (cc.dpy, PictOpSrc, cc2.src, None, cc2.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
646
647 return cc2;
648}
649
650ecb_noinline static void
651extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
652{
653 int32_t x = clamp (c, cl0, cl1);
654 c -= x;
655 xc = x;
656}
657
658ecb_noinline static bool
659extract (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)
660{
661 extract (cl0, cl1, r, xr);
662 extract (cl0, cl1, g, xg);
663 extract (cl0, cl1, b, xb);
664 extract (cl0, cl1, a, xa);
665
666 return xr | xg | xb | xa;
150} 667}
151 668
152void 669void
153rxvt_img::brightness (double r, double g, double b, double a) 670rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
154{ 671{
672 unshare ();
673
155 Display *dpy = s->display->dpy; 674 Display *dpy = s->dpy;
156 Picture src = create_xrender_mask (dpy, pm, True);
157 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 675 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
158 676
677 // loop should not be needed for brightness, as only -1..1 makes sense
678 //while (r | g | b | a)
679 {
680 unsigned short xr, xg, xb, xa;
159 XRenderColor mask_c; 681 XRenderColor mask_c;
160 mask_c.red = float_to_component (r); 682
161 mask_c.green = float_to_component (g); 683 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); 684 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
165 685
166 XRenderComposite (dpy, PictOpAdd, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 686 if (extract (-65535, 0, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
687 {
688 XRenderColor mask_w = { 65535, 65535, 65535, 65535 };
689 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
690 mask_c.red = -mask_c.red; //TODO: verify that doing clamp, assign, and negation does the right thing
691 mask_c.green = -mask_c.green;
692 mask_c.blue = -mask_c.blue;
693 mask_c.alpha = -mask_c.alpha;
694 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
695 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
696 }
697 }
698
699 XRenderFreePicture (dpy, dst);
167} 700}
168 701
169void 702void
170rxvt_img::contrast (double r, double g, double b, double a) 703rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
171{ 704{
172 if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL)) 705 if (r < 0 || g < 0 || b < 0 || a < 0)
173 return; 706 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
174 707
175 Display *dpy = s->display->dpy; 708 // premultiply (yeah, these are not exact, sue me or fix it)
176 Picture src = create_xrender_mask (dpy, pm, True); 709 r = (r * (a >> 8)) >> 8;
177 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 710 g = (g * (a >> 8)) >> 8;
711 b = (b * (a >> 8)) >> 8;
178 712
713 composer cc (this);
714 rxvt_img *img = cc;
715 img->fill (rgba (0, 0, 0, 0));
716
717 cc.mask (true);
718
719 //TODO: this operator does not yet implement some useful contrast
720 while (r | g | b | a)
721 {
722 unsigned short xr, xg, xb, xa;
179 XRenderColor mask_c; 723 XRenderColor mask_c;
180 mask_c.red = float_to_component (r); 724
181 mask_c.green = float_to_component (g); 725 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); 726 {
183 mask_c.alpha = float_to_component (a);
184 XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1); 727 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); 728 XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
729 }
730 }
731
732 ::swap (img->ref, ref);
733 ::swap (img->pm , pm );
734
735 delete img;
187} 736}
188 737
189void 738void
190rxvt_img::render (GdkPixbuf *pixbuf, int src_x, int src_y, int width, int height, int dst_x, int dst_y) 739rxvt_img::draw (rxvt_img *img, int op, nv mask)
191{ 740{
192 //TODO 741 unshare ();
193}
194 742
743 composer cc (img, this);
744
745 if (mask != 1.)
746 cc.mask (rgba (0, 0, 0, float_to_component (mask)));
747
748 XRenderComposite (cc.dpy, op, cc.src, cc.msk, cc.dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h);
749}
750
195rxvt_img * 751rxvt_img *
196rxvt_img::copy () 752rxvt_img::clone ()
197{ 753{
198 GC gc = XCreateGC (s->display->dpy, pm, 0, 0); 754 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} 755}
204 756
205rxvt_img * 757rxvt_img *
206rxvt_img::transform (int new_width, int new_height, double matrix[16]) 758rxvt_img::reify ()
207{ 759{
208 //TODO 760 if (x == 0 && y == 0 && w == ref->w && h == ref->h)
761 return clone ();
762
763 // add an alpha channel if...
764 bool alpha = !format->direct.alphaMask // pixmap has none yet
765 && (x || y) // we need one because of non-zero offset
766 && repeat == RepeatNone; // and we have no good pixels to fill with
767
768 composer cc (this, new rxvt_img (s, alpha ? find_alpha_format_for (s->dpy, format) : format,
769 0, 0, w, h, repeat));
770
771 if (repeat == RepeatNone)
772 {
773 XRenderColor rc = { 0, 0, 0, 0 };
774 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
775 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
776 }
777 else
778 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
779
780 return cc;
781}
782
783rxvt_img *
784rxvt_img::sub_rect (int x, int y, int width, int height)
785{
786 rxvt_img *img = clone ();
787
788 img->x -= x;
789 img->y -= y;
790
791 if (w != width || h != height)
792 {
793 img->w = width;
794 img->h = height;
795
796 rxvt_img *img2 = img->reify ();
797 delete img;
798 img = img2;
799 }
800
801 return img;
802}
803
804rxvt_img *
805rxvt_img::transform (const nv matrix[3][3])
806{
807 return transform (mat3x3 (&matrix[0][0]));
808}
809
810rxvt_img *
811rxvt_img::transform (const nv *matrix)
812{
813 mat3x3 m (matrix);
814
815 // calculate new pixel bounding box coordinates
816 nv rmin[2], rmax[2];
817
818 for (int i = 0; i < 2; ++i)
819 {
820 nv v;
821
822 v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v;
823 v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v);
824 v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
825 v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
826 }
827
828 float sx = rmin [0] - x;
829 float sy = rmin [1] - y;
830
831 // TODO: adjust matrix for subpixel accuracy
832 int nx = floor (rmin [0]);
833 int ny = floor (rmin [1]);
834
835 int new_width = ceil (rmax [0] - rmin [0]);
836 int new_height = ceil (rmax [1] - rmin [1]);
837
838 mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
839
840 composer cc (this, new rxvt_img (s, format, nx, ny, new_width, new_height, repeat));
841
842 XTransform xfrm;
843
844 for (int i = 0; i < 3; ++i)
845 for (int j = 0; j < 3; ++j)
846 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
847
848 XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
849 XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
850 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
851
852 return cc;
209} 853}
210 854
211rxvt_img * 855rxvt_img *
212rxvt_img::scale (int new_width, int new_height) 856rxvt_img::scale (int new_width, int new_height)
213{ 857{
214 // use transform 858 if (w == new_width && h == new_height)
215 //TODO 859 return clone ();
216}
217 860
218rxvt_img * 861 int old_repeat_mode = repeat;
219rxvt_img::convert_to (XRenderPictFormat *new_format) 862 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 863
223 Display *dpy = s->display->dpy; 864 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 865
227 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 866 repeat = old_repeat_mode;
228 867 img->repeat = repeat;
229 XRenderFreePicture (dpy, src);
230 XRenderFreePicture (dpy, dst);
231 868
232 return img; 869 return img;
233} 870}
234 871
872rxvt_img *
873rxvt_img::rotate (int cx, int cy, nv phi)
874{
875 move (-cx, -cy);
876 rxvt_img *img = transform (mat3x3::rotate (phi));
877 move ( cx, cy);
878 img->move (cx, cy);
879
880 return img;
881}
882
883rxvt_img *
884rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
885{
886 if (new_format == format)
887 return clone ();
888
889 composer cc (this, new rxvt_img (s, new_format, x, y, w, h, repeat));
890
891 int op = PictOpSrc;
892
893 if (format->direct.alphaMask && !new_format->direct.alphaMask)
894 {
895 // does it have to be that complicated
896 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
897 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
898
899 op = PictOpOver;
900 }
901
902 XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
903
904 return cc;
905}
906
907rxvt_img *
908rxvt_img::tint (const rgba &c)
909{
910 composer cc (this);
911 cc.mask (true);
912 cc.fill (c);
913
914 XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
915
916 return cc;
917}
918
919rxvt_img *
920rxvt_img::filter (const char *name, int nparams, nv *params)
921{
922 composer cc (this);
923
924 XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
925
926 for (int i = 0; i < nparams; ++i)
927 xparams [i] = XDoubleToFixed (params [i]);
928
929 XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
930
931 XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
932
933 return cc;
934}
935
235#endif 936#endif
236 937

Diff Legend

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