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.100 by root, Mon Jul 2 02:01:41 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 x = 1, int y = 1)
176 {
177 Pixmap pixmap = XCreatePixmap (dpy, srcimg->pm, x, y, 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 if (!pb_has_alpha)
355 for (int x = 0; x < width; x++)
356 {
357 uint8_t r = *src++;
358 uint8_t g = *src++;
359 uint8_t b = *src++;
360
361 uint32_t v = (255 << 24) | (r << 16) | (g << 8) | b;
362
363 if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch)
364 v = ecb_bswap32 (v);
365
366 *dst++ = v;
367 }
368 else
369 for (int x = 0; x < width; x++)
370 {
371 uint32_t v = *(uint32_t *)src; src += 4;
372
373 if (ecb_big_endian ())
374 v = ecb_bswap32 (v);
375
376 v = ecb_rotl32 (v, 8); // abgr to bgra
377
378 if (!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 (s->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 (s->dpy, s->display->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 (s, format, x, y, w, h, repeat);
446 img->alloc ();
447
448 return img;
449}
450
451Picture
452rxvt_img::picture ()
453{
454 Display *dpy = s->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 (s->dpy, s->display->root, ref->w, ref->h, format->depth);
470 GC gc = XCreateGC (s->dpy, pm, 0, 0);
471 XCopyArea (s->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);
54 XFreeGC (s->display->dpy, gc); 472 XFreeGC (s->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 = s->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 (s, find_alpha_format_for (s->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 (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))
82 return; 540 return clone ();
83 541
84 Display *dpy = s->display->dpy; 542 Display *dpy = s->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 = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
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 free (params);
591
133 XRenderFreePicture (dpy, src); 592 XRenderFreePicture (dpy, src);
134 XRenderFreePicture (dpy, dst); 593 XRenderFreePicture (dpy, dst);
135} 594 XRenderFreePicture (dpy, tmp);
136 595
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; 596 return img;
597}
598
599ecb_noinline static void
600extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
601{
602 int32_t x = clamp (c, cl0, cl1);
603 c -= x;
604 xc = x;
605}
606
607ecb_noinline static bool
608extract (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)
609{
610 extract (cl0, cl1, r, xr);
611 extract (cl0, cl1, g, xg);
612 extract (cl0, cl1, b, xb);
613 extract (cl0, cl1, a, xa);
614
615 return xr | xg | xb | xa;
150} 616}
151 617
152void 618void
153rxvt_img::brightness (double r, double g, double b, double a) 619rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
154{ 620{
621 unshare ();
622
155 Display *dpy = s->display->dpy; 623 Display *dpy = s->dpy;
156 Picture src = create_xrender_mask (dpy, pm, True);
157 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 624 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
158 625
626 // loop should not be needed for brightness, as only -1..1 makes sense
627 //while (r | g | b | a)
628 {
629 unsigned short xr, xg, xb, xa;
159 XRenderColor mask_c; 630 XRenderColor mask_c;
160 mask_c.red = float_to_component (r); 631
161 mask_c.green = float_to_component (g); 632 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); 633 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
165 634
166 XRenderComposite (dpy, PictOpAdd, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 635 if (extract (-65535, 0, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
636 {
637 XRenderColor mask_w = { 65535, 65535, 65535, 65535 };
638 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
639 mask_c.red = -mask_c.red; //TODO: verify that doing clamp, assign, and negation does the right thing
640 mask_c.green = -mask_c.green;
641 mask_c.blue = -mask_c.blue;
642 mask_c.alpha = -mask_c.alpha;
643 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
644 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
645 }
646 }
647
648 XRenderFreePicture (dpy, dst);
167} 649}
168 650
169void 651void
170rxvt_img::contrast (double r, double g, double b, double a) 652rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
171{ 653{
172 if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL)) 654 if (r < 0 || g < 0 || b < 0 || a < 0)
173 return; 655 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
174 656
175 Display *dpy = s->display->dpy; 657 // premultiply (yeah, these are not exact, sue me or fix it)
176 Picture src = create_xrender_mask (dpy, pm, True); 658 r = (r * (a >> 8)) >> 8;
177 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 659 g = (g * (a >> 8)) >> 8;
660 b = (b * (a >> 8)) >> 8;
178 661
662 composer cc (this);
663 rxvt_img *img = cc;
664 img->fill (rgba (0, 0, 0, 0));
665
666 cc.mask (true);
667
668 //TODO: this operator does not yet implement some useful contrast
669 while (r | g | b | a)
670 {
671 unsigned short xr, xg, xb, xa;
179 XRenderColor mask_c; 672 XRenderColor mask_c;
180 mask_c.red = float_to_component (r); 673
181 mask_c.green = float_to_component (g); 674 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); 675 {
183 mask_c.alpha = float_to_component (a);
184 XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1); 676 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); 677 XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
678 }
679 }
680
681 ::swap (img->ref, ref);
682 ::swap (img->pm , pm );
683
684 delete img;
187} 685}
188 686
189void 687void
190rxvt_img::render (GdkPixbuf *pixbuf, int src_x, int src_y, int width, int height, int dst_x, int dst_y) 688rxvt_img::draw (rxvt_img *img, int op, nv mask)
191{ 689{
192 //TODO 690 unshare ();
193}
194 691
692 composer cc (img, this);
693
694 if (mask != 1.)
695 cc.mask (rgba (0, 0, 0, float_to_component (mask)));
696
697 XRenderComposite (cc.dpy, op, cc.src, cc.msk, cc.dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h);
698}
699
195rxvt_img * 700rxvt_img *
196rxvt_img::copy () 701rxvt_img::clone ()
197{ 702{
198 GC gc = XCreateGC (s->display->dpy, pm, 0, 0); 703 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} 704}
204 705
205rxvt_img * 706rxvt_img *
206rxvt_img::transform (int new_width, int new_height, double matrix[16]) 707rxvt_img::reify ()
207{ 708{
208 //TODO 709 if (x == 0 && y == 0 && w == ref->w && h == ref->h)
710 return clone ();
711
712 Display *dpy = s->dpy;
713
714 // add an alpha channel if...
715 bool alpha = !format->direct.alphaMask // pixmap has none yet
716 && (x || y) // we need one because of non-zero offset
717 && repeat == RepeatNone; // and we have no good pixels to fill with
718
719 composer cc (this, new rxvt_img (s, alpha ? find_alpha_format_for (s->dpy, format) : format,
720 0, 0, w, h, repeat));
721
722 if (alpha)
723 {
724 XRenderColor rc = { 0, 0, 0, 0 };
725 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
726 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
727 }
728 else
729 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
730
731 return cc;
732}
733
734rxvt_img *
735rxvt_img::sub_rect (int x, int y, int width, int height)
736{
737 rxvt_img *img = clone ();
738
739 img->x -= x;
740 img->y -= y;
741
742 if (w != width || h != height)
743 {
744 img->w = width;
745 img->h = height;
746
747 rxvt_img *img2 = img->reify ();
748 delete img;
749 img = img2;
750 }
751
752 return img;
753}
754
755rxvt_img *
756rxvt_img::transform (const nv matrix[3][3])
757{
758 return transform (mat3x3 (&matrix[0][0]));
759}
760
761rxvt_img *
762rxvt_img::transform (const nv *matrix)
763{
764 mat3x3 m (matrix);
765
766 // calculate new pixel bounding box coordinates
767 nv rmin[2], rmax[2];
768
769 for (int i = 0; i < 2; ++i)
770 {
771 nv v;
772
773 v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v;
774 v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v);
775 v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
776 v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
777 }
778
779 float sx = rmin [0] - x;
780 float sy = rmin [1] - y;
781
782 // TODO: adjust matrix for subpixel accuracy
783 int nx = floor (rmin [0]);
784 int ny = floor (rmin [1]);
785
786 int new_width = ceil (rmax [0] - rmin [0]);
787 int new_height = ceil (rmax [1] - rmin [1]);
788
789 mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
790
791 composer cc (this, new rxvt_img (s, format, nx, ny, new_width, new_height, repeat));
792
793 XTransform xfrm;
794
795 for (int i = 0; i < 3; ++i)
796 for (int j = 0; j < 3; ++j)
797 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
798
799 XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
800 XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
801 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
802
803 return cc;
209} 804}
210 805
211rxvt_img * 806rxvt_img *
212rxvt_img::scale (int new_width, int new_height) 807rxvt_img::scale (int new_width, int new_height)
213{ 808{
214 // use transform 809 if (w == new_width && h == new_height)
215 //TODO 810 return clone ();
216}
217 811
218rxvt_img * 812 int old_repeat_mode = repeat;
219rxvt_img::convert_to (XRenderPictFormat *new_format) 813 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 814
223 Display *dpy = s->display->dpy; 815 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 816
227 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 817 repeat = old_repeat_mode;
228 818 img->repeat = repeat;
229 XRenderFreePicture (dpy, src);
230 XRenderFreePicture (dpy, dst);
231 819
232 return img; 820 return img;
233} 821}
234 822
823rxvt_img *
824rxvt_img::rotate (int cx, int cy, nv phi)
825{
826 move (-cx, -cy);
827 rxvt_img *img = transform (mat3x3::rotate (phi));
828 move ( cx, cy);
829 img->move (cx, cy);
830
831 return img;
832}
833
834rxvt_img *
835rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
836{
837 if (new_format == format)
838 return clone ();
839
840 composer cc (this, new rxvt_img (s, new_format, x, y, w, h, repeat));
841
842 int op = PictOpSrc;
843
844 if (format->direct.alphaMask && !new_format->direct.alphaMask)
845 {
846 // does it have to be that complicated
847 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
848 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
849
850 op = PictOpOver;
851 }
852
853 XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
854
855 return cc;
856}
857
858rxvt_img *
859rxvt_img::tint (const rgba &c)
860{
861 composer cc (this);
862 cc.mask (true);
863 cc.fill (c);
864
865 XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
866
867 return cc;
868}
869
870rxvt_img *
871rxvt_img::filter (const char *name, int nparams, nv *params)
872{
873 composer cc (this);
874
875 XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
876
877 for (int i = 0; i < nparams; ++i)
878 xparams [i] = XDoubleToFixed (params [i]);
879
880 XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
881
882 XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
883
884 return cc;
885}
886
235#endif 887#endif
236 888

Diff Legend

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