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.13 by root, Mon Jun 4 15:30:41 2012 UTC vs.
Revision 1.80 by root, Tue Jun 12 18:25:57 2012 UTC

2#include "../config.h" 2#include "../config.h"
3#include "rxvt.h" 3#include "rxvt.h"
4 4
5#if HAVE_IMG 5#if HAVE_IMG
6 6
7#define float_to_component(d) ((d) * 65535.99)
8
9rxvt_img::rxvt_img (rxvt_screen *screen, XRenderPictFormat *format, int width, int height) 7rxvt_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) 8: s(screen), x(x), y(y), w(width), h(height), format(format), repeat(repeat),
9 pm(0), ref(0)
17{ 10{
11}
12
13rxvt_img::rxvt_img (const rxvt_img &img)
14: 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)
15{
16 ++ref->cnt;
17}
18
19rxvt_img *
20rxvt_img::new_from_root (rxvt_screen *s)
21{
22 Display *dpy = s->display->dpy;
23 unsigned int root_pm_w, root_pm_h;
24 Pixmap root_pixmap = s->display->get_pixmap_property (s->display->xa[XA_XROOTPMAP_ID]);
25 if (root_pixmap == None)
26 root_pixmap = s->display->get_pixmap_property (s->display->xa[XA_ESETROOT_PMAP_ID]);
27
28 if (root_pixmap == None)
29 return 0;
30
31 Window wdummy;
32 int idummy;
33 unsigned int udummy;
34
35 if (!XGetGeometry (dpy, root_pixmap, &wdummy, &idummy, &idummy, &root_pm_w, &root_pm_h, &udummy, &udummy))
36 return 0;
37
38 rxvt_img *img = new rxvt_img (
39 s,
40 XRenderFindVisualFormat (dpy, DefaultVisual (dpy, s->display->screen)),
41 0,
42 0,
43 root_pm_w,
44 root_pm_h
45 );
46
47 img->pm = root_pixmap;
48 img->ref = new pixref (root_pm_w, root_pm_h);
49 img->ref->ours = false;
50
51 return img;
52}
53
54# if HAVE_PIXBUF
55
56rxvt_img *
57rxvt_img::new_from_pixbuf (rxvt_screen *s, GdkPixbuf *pb)
58{
59 Display *dpy = s->display->dpy;
60
61 int width = gdk_pixbuf_get_width (pb);
62 int height = gdk_pixbuf_get_height (pb);
63
64 if (width > 32767 || height > 32767) // well, we *could* upload in chunks
65 rxvt_fatal ("rxvt_img::new_from_pixbuf: image too big (maximum size 32768x32768).\n");
66
67 // since we require rgb24/argb32 formats from xrender we assume
68 // that both 24 and 32 bpp MUST be supported by any screen that supports xrender
69
70 int byte_order = ecb_big_endian () ? MSBFirst : LSBFirst;
71
72 XImage xi;
73
74 xi.width = width;
75 xi.height = height;
76 xi.xoffset = 0;
77 xi.format = ZPixmap;
78 xi.byte_order = ImageByteOrder (dpy);
79 xi.bitmap_unit = 0; //XY only, unused
80 xi.bitmap_bit_order = 0; //XY only, unused
81 xi.bitmap_pad = BitmapPad (dpy);
82 xi.depth = 32;
83 xi.bytes_per_line = 0;
84 xi.bits_per_pixel = 32; //Z only
85 xi.red_mask = 0x00000000; //Z only, unused
86 xi.green_mask = 0x00000000; //Z only, unused
87 xi.blue_mask = 0x00000000; //Z only, unused
88 xi.obdata = 0; // probably unused
89
90 bool byte_order_mismatch = byte_order != xi.byte_order;
91
92 if (!XInitImage (&xi))
93 rxvt_fatal ("unable to initialise ximage, please report.\n");
94
95 if (height > INT_MAX / xi.bytes_per_line)
96 rxvt_fatal ("rxvt_img::new_from_pixbuf: image too big for Xlib.\n");
97
98 xi.data = (char *)rxvt_malloc (height * xi.bytes_per_line);
99
100 int rowstride = gdk_pixbuf_get_rowstride (pb);
101 bool pb_has_alpha = gdk_pixbuf_get_has_alpha (pb);
102 unsigned char *row = gdk_pixbuf_get_pixels (pb);
103
104 char *line = xi.data;
105
106 for (int y = 0; y < height; y++)
107 {
108 unsigned char *src = row;
109 uint32_t *dst = (uint32_t *)line;
110
111 if (!pb_has_alpha)
112 for (int x = 0; x < width; x++)
113 {
114 uint8_t r = *src++;
115 uint8_t g = *src++;
116 uint8_t b = *src++;
117
118 uint32_t v = (255 << 24) | (r << 16) | (g << 8) | b;
119
120 if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch)
121 v = ecb_bswap32 (v);
122
123 *dst++ = v;
124 }
125 else
126 for (int x = 0; x < width; x++)
127 {
128 uint32_t v = *(uint32_t *)src; src += 4;
129
130 if (ecb_big_endian ())
131 v = ecb_bswap32 (v);
132
133 v = ecb_rotl32 (v, 8); // abgr to bgra
134
135 if (!byte_order_mismatch)
136 v = ecb_bswap32 (v);
137
138 *dst++ = v;
139 }
140
141 row += rowstride;
142 line += xi.bytes_per_line;
143 }
144
145 rxvt_img *img = new rxvt_img (s, XRenderFindStandardFormat (dpy, PictStandardARGB32), 0, 0, width, height);
146 img->alloc ();
147
148 GC gc = XCreateGC (dpy, img->pm, 0, 0);
149 XPutImage (dpy, img->pm, gc, &xi, 0, 0, 0, 0, width, height);
150 XFreeGC (dpy, gc);
151
152 free (xi.data);
153
154 return img;
18} 155}
19 156
20rxvt_img * 157rxvt_img *
21rxvt_img::new_from_file (rxvt_screen *s, const char *filename) 158rxvt_img::new_from_file (rxvt_screen *s, const char *filename)
22{ 159{
24 GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err); 161 GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err);
25 162
26 if (!pb) 163 if (!pb)
27 rxvt_fatal ("rxvt_img::new_from_file: %s\n", err->message); 164 rxvt_fatal ("rxvt_img::new_from_file: %s\n", err->message);
28 165
29 rxvt_img *img = new rxvt_img ( 166 rxvt_img *img = new_from_pixbuf (s, pb);
30 s,
31 XRenderFindStandardFormat (s->display->dpy, gdk_pixbuf_get_has_alpha (pb) ? PictStandardARGB32 : PictStandardRGB24),
32 gdk_pixbuf_get_width (pb),
33 gdk_pixbuf_get_height (pb)
34 );
35 167
36 img->render (pb, 0, 0, img->w, img->h, 0, 0); 168 g_object_unref (pb);
37 169
170 return img;
171}
172
173# endif
174
175void
176rxvt_img::destroy ()
177{
178 if (--ref->cnt)
38 return img; 179 return;
180
181 if (pm && ref->ours)
182 XFreePixmap (s->display->dpy, pm);
183
184 delete ref;
39} 185}
40 186
41rxvt_img::~rxvt_img () 187rxvt_img::~rxvt_img ()
42{ 188{
43 if (!shared) 189 destroy ();
44 XFreePixmap (s->display->dpy, pm); 190}
191
192void
193rxvt_img::alloc ()
194{
195 pm = XCreatePixmap (s->display->dpy, s->display->root, w, h, format->depth);
196 ref = new pixref (w, h);
197}
198
199Picture
200rxvt_img::src_picture ()
201{
202 Display *dpy = s->display->dpy;
203
204 XRenderPictureAttributes pa;
205 pa.repeat = repeat;
206 Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
207
208 return pic;
45} 209}
46 210
47void 211void
48rxvt_img::unshare () 212rxvt_img::unshare ()
49{ 213{
50 if (!shared) 214 if (ref->cnt == 1 && ref->ours)
51 return; 215 return;
52 216
53 rxvt_img *img = clone (); 217 Pixmap pm2 = XCreatePixmap (s->display->dpy, s->display->root, ref->w, ref->h, format->depth);
218 GC gc = XCreateGC (s->display->dpy, pm, 0, 0);
219 XCopyArea (s->display->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);
220 XFreeGC (s->display->dpy, gc);
54 221
55 ::swap (pm , img->pm); 222 destroy ();
56 ::swap (shared, img->shared);
57 223
58 delete img; 224 pm = pm2;
225 ref = new pixref (ref->w, ref->h);
59} 226}
60 227
61void 228void
62rxvt_img::fill (const rxvt_color &c) 229rxvt_img::fill (const rxvt_color &c)
63{ 230{
64 XGCValues gcv; 231 rgba cc;
65 gcv.foreground = c; 232 c.get (cc);
66 GC gc = XCreateGC (s->display->dpy, pm, GCForeground, &gcv); 233 XRenderColor rc = { cc.r, cc.g, cc.b, cc.a };
67 XFillRectangle (s->display->dpy, pm, gc, 0, 0, w, h); 234
68 XFreeGC (s->display->dpy, gc); 235 Display *dpy = s->display->dpy;
236 Picture src = src_picture ();
237 XRenderFillRectangle (dpy, PictOpSrc, src, &rc, 0, 0, w, h);
238 XRenderFreePicture (dpy, src);
69} 239}
70 240
71static void 241static void
72get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params) 242get_gaussian_kernel (int radius, int width, double *kernel, XFixed *params)
73{ 243{
87 257
88 for (int i = 0; i < width; i++) 258 for (int i = 0; i < width; i++)
89 params[i+2] = XDoubleToFixed (kernel[i] / sum); 259 params[i+2] = XDoubleToFixed (kernel[i] / sum);
90} 260}
91 261
92void 262rxvt_img *
93rxvt_img::blur (int rh, int rv) 263rxvt_img::blur (int rh, int rv)
94{ 264{
95 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV)) 265 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))
96 return; 266 return clone ();
97 267
98 Display *dpy = s->display->dpy; 268 Display *dpy = s->display->dpy;
99 int size = max (rh, rv) * 2 + 1; 269 int size = max (rh, rv) * 2 + 1;
100 double *kernel = (double *)malloc (size * sizeof (double)); 270 double *kernel = (double *)malloc (size * sizeof (double));
101 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 271 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
272 rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat);
273 img->alloc ();
102 274
103 XRenderPictureAttributes pa; 275 XRenderPictureAttributes pa;
104
105 pa.repeat = RepeatPad; 276 pa.repeat = RepeatPad;
106 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 277 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
278 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
279
107 Pixmap tmp = XCreatePixmap (dpy, pm, w, h, format->depth); 280 Pixmap tmp_pm = XCreatePixmap (dpy, pm, w, h, format->depth);
108 Picture dst = XRenderCreatePicture (dpy, tmp, format, CPRepeat, &pa); 281 Picture tmp = XRenderCreatePicture (dpy, tmp_pm , format, CPRepeat, &pa);
109 XFreePixmap (dpy, tmp); 282 XFreePixmap (dpy, tmp_pm);
110 283
111 if (kernel && params) 284 if (kernel && params)
112 { 285 {
113 size = rh * 2 + 1; 286 size = rh * 2 + 1;
114 get_gaussian_kernel (rh, size, kernel, params); 287 get_gaussian_kernel (rh, size, kernel, params);
115 288
116 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2); 289 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
117 XRenderComposite (dpy, 290 XRenderComposite (dpy,
118 PictOpSrc, 291 PictOpSrc,
119 src, 292 src,
293 None,
294 tmp,
295 0, 0,
296 0, 0,
297 0, 0,
298 w, h);
299
300 size = rv * 2 + 1;
301 get_gaussian_kernel (rv, size, kernel, params);
302 ::swap (params[0], params[1]);
303
304 XRenderSetPictureFilter (dpy, tmp, FilterConvolution, params, size+2);
305 XRenderComposite (dpy,
306 PictOpSrc,
307 tmp,
120 None, 308 None,
121 dst, 309 dst,
122 0, 0, 310 0, 0,
123 0, 0, 311 0, 0,
124 0, 0, 312 0, 0,
125 w, h); 313 w, h);
126
127 ::swap (src, dst);
128
129 size = rv * 2 + 1;
130 get_gaussian_kernel (rv, size, kernel, params);
131 ::swap (params[0], params[1]);
132
133 XRenderSetPictureFilter (dpy, src, FilterConvolution, params, size+2);
134 XRenderComposite (dpy,
135 PictOpSrc,
136 src,
137 None,
138 dst,
139 0, 0,
140 0, 0,
141 0, 0,
142 w, h);
143 } 314 }
144 315
145 free (kernel); 316 free (kernel);
146 free (params); 317 free (params);
318
147 XRenderFreePicture (dpy, src); 319 XRenderFreePicture (dpy, src);
148 XRenderFreePicture (dpy, dst); 320 XRenderFreePicture (dpy, dst);
321 XRenderFreePicture (dpy, tmp);
322
323 return img;
149} 324}
150 325
151static Picture 326static Picture
152create_xrender_mask (Display *dpy, Drawable drawable, Bool argb) 327create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)
153{ 328{
154 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8); 329 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
155 330
156 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8); 331 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
157 XRenderPictureAttributes pa; 332 XRenderPictureAttributes pa;
158 pa.repeat = True; 333 pa.repeat = RepeatNormal;
334 pa.component_alpha = component_alpha;
159 Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat, &pa); 335 Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat | CPComponentAlpha, &pa);
160 336
161 XFreePixmap (dpy, pixmap); 337 XFreePixmap (dpy, pixmap);
162 338
163 return mask; 339 return mask;
164} 340}
165 341
342static void
343extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
344{
345 int32_t x = clamp (c, cl0, cl1);
346 c -= x;
347 xc = x;
348}
349
350static bool
351extract (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)
352{
353 extract (cl0, cl1, r, xr);
354 extract (cl0, cl1, g, xg);
355 extract (cl0, cl1, b, xb);
356 extract (cl0, cl1, a, xa);
357
358 return xr | xg | xb | xa;
359}
360
166void 361void
167rxvt_img::brightness (double r, double g, double b, double a) 362rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
168{ 363{
364 unshare ();
365
169 Display *dpy = s->display->dpy; 366 Display *dpy = s->display->dpy;
170 Picture src = create_xrender_mask (dpy, pm, True);
171 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 367 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
172 368
369 // loop should not be needed for brightness, as only -1..1 makes sense
370 //while (r | g | b | a)
371 {
372 unsigned short xr, xg, xb, xa;
173 XRenderColor mask_c; 373 XRenderColor mask_c;
174 mask_c.red = float_to_component (r); 374
175 mask_c.green = float_to_component (g); 375 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
176 mask_c.blue = float_to_component (b);
177 mask_c.alpha = float_to_component (a);
178 XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1); 376 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
179 377
180 XRenderComposite (dpy, PictOpAdd, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 378 if (extract (-65535, 0, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
379 {
380 XRenderColor mask_w = { 65535, 65535, 65535, 65535 };
381 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
382 mask_c.red = -mask_c.red; //TODO: verify that doing clamp, assign, and negation does the right thing
383 mask_c.green = -mask_c.green;
384 mask_c.blue = -mask_c.blue;
385 mask_c.alpha = -mask_c.alpha;
386 XRenderFillRectangle (dpy, PictOpAdd, dst, &mask_c, 0, 0, w, h);
387 XRenderFillRectangle (dpy, PictOpDifference, dst, &mask_w, 0, 0, w, h);
388 }
389 }
390
391 XRenderFreePicture (dpy, dst);
181} 392}
182 393
183void 394void
184rxvt_img::contrast (double r, double g, double b, double a) 395rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
185{ 396{
186 if (!(s->display->flags & DISPLAY_HAS_RENDER_MUL)) 397 if (r < 0 || g < 0 || b < 0 || a < 0)
187 return; 398 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
188 399
400 rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat);
401 img->alloc ();
402
403 {
404 rxvt_color empty;
405 empty.set (s, rgba (0, 0, 0, 0));
406 img->fill (empty);
407 }
408
409 // premultiply (yeah, these are not exact, sue me or fix it)
410 r = (r * (a >> 8)) >> 8;
411 g = (g * (a >> 8)) >> 8;
412 b = (b * (a >> 8)) >> 8;
413
189 Display *dpy = s->display->dpy; 414 Display *dpy = s->display->dpy;
190 Picture src = create_xrender_mask (dpy, pm, True); 415
416 Picture src = src_picture ();
191 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 417 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
418 Picture mul = create_xrender_mask (dpy, pm, True, True);
192 419
420 //TODO: this operator does not yet implement some useful contrast
421 while (r | g | b | a)
422 {
423 unsigned short xr, xg, xb, xa;
193 XRenderColor mask_c; 424 XRenderColor mask_c;
194 mask_c.red = float_to_component (r); 425
195 mask_c.green = float_to_component (g); 426 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
196 mask_c.blue = float_to_component (b); 427 {
197 mask_c.alpha = float_to_component (a);
198 XRenderFillRectangle (dpy, PictOpSrc, src, &mask_c, 0, 0, 1, 1); 428 XRenderFillRectangle (dpy, PictOpSrc, mul, &mask_c, 0, 0, 1, 1);
199
200 XRenderComposite (dpy, PictOpMultiply, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 429 XRenderComposite (dpy, PictOpAdd, src, mul, dst, 0, 0, 0, 0, 0, 0, w, h);
201} 430 }
431 }
202 432
203void 433 XRenderFreePicture (dpy, mul);
204rxvt_img::render (GdkPixbuf *pixbuf, int src_x, int src_y, int width, int height, int dst_x, int dst_y) 434 XRenderFreePicture (dpy, dst);
205{ 435 XRenderFreePicture (dpy, src);
206 //TODO 436
437 ::swap (img->ref, ref);
438 ::swap (img->pm , pm );
439
440 delete img;
207} 441}
208 442
209rxvt_img * 443rxvt_img *
210rxvt_img::clone () 444rxvt_img::clone ()
211{ 445{
212 GC gc = XCreateGC (s->display->dpy, pm, 0, 0); 446 return new rxvt_img (*this);
213 Pixmap pm2 = XCreatePixmap (s->display->dpy, pm, w, h, format->depth);
214 XCopyArea (s->display->dpy, pm, pm2, gc, 0, 0, w, h, 0, 0);
215 XFreeGC (s->display->dpy, gc);
216 return new rxvt_img (s, format, w, h, pm2);
217} 447}
218 448
219rxvt_img * 449static XRenderPictFormat *
220rxvt_img::transform (int new_width, int new_height, int repeat, double matrix[9]) 450find_alpha_format_for (Display *dpy, XRenderPictFormat *format)
221{ 451{
222 rxvt_img *img = new rxvt_img (s, format, new_width, new_height); 452 if (format->direct.alphaMask)
453 return format; // already has alpha
223 454
455 // try to find a suitable alpha format, one bit alpha is enough for our purposes
456 if (format->type == PictTypeDirect)
457 for (int n = 0; XRenderPictFormat *f = XRenderFindFormat (dpy, 0, 0, n); ++n)
458 if (f->direct.alphaMask
459 && f->type == PictTypeDirect
460 && ecb_popcount32 (f->direct.redMask ) >= ecb_popcount32 (format->direct.redMask )
461 && ecb_popcount32 (f->direct.greenMask) >= ecb_popcount32 (format->direct.greenMask)
462 && ecb_popcount32 (f->direct.blueMask ) >= ecb_popcount32 (format->direct.blueMask ))
463 return f;
464
465 // should be a very good fallback
466 return XRenderFindStandardFormat (dpy, PictStandardARGB32);
467}
468
469rxvt_img *
470rxvt_img::reify ()
471{
472 if (x == 0 && y == 0 && w == ref->w && h == ref->h)
473 return clone ();
474
224 Display *dpy = s->display->dpy; 475 Display *dpy = s->display->dpy;
225 XRenderPictureAttributes pa; 476
226 pa.repeat = repeat; 477 // add an alpha channel if...
227 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 478 bool alpha = !format->direct.alphaMask // pixmap has none yet
479 && (x || y) // we need one because of non-zero offset
480 && repeat == RepeatNone; // and we have no good pixels to fill with
481
482 rxvt_img *img = new rxvt_img (s, alpha ? find_alpha_format_for (dpy, format) : format, 0, 0, w, h, repeat);
483 img->alloc ();
484
485 Picture src = src_picture ();
228 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0); 486 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
487
488 if (alpha)
489 {
490 XRenderColor rc = { 0, 0, 0, 0 };
491 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
492 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, -x, -y, ref->w, ref->h);
493 }
494 else
495 XRenderComposite (dpy, PictOpSrc, src, None, dst, x, y, 0, 0, 0, 0, w, h);
496
497 XRenderFreePicture (dpy, src);
498 XRenderFreePicture (dpy, dst);
499
500 return img;
501}
502
503rxvt_img *
504rxvt_img::sub_rect (int x, int y, int width, int height)
505{
506 rxvt_img *img = clone ();
507
508 img->x += x;
509 img->y += y;
510
511 if (w != width || h != height)
512 {
513 img->w = width;
514 img->h = height;
515
516 rxvt_img *img2 = img->reify ();
517 delete img;
518 img = img2;
519 }
520
521 return img;
522}
523
524static void
525mat_invert (double mat[3][3], double (&inv)[3][3])
526{
527 double s0 = mat [2][2] * mat [1][1] - mat [2][1] * mat [1][2];
528 double s1 = mat [2][1] * mat [0][2] - mat [2][2] * mat [0][1];
529 double s2 = mat [1][2] * mat [0][1] - mat [1][1] * mat [0][2];
530
531 double invdet = 1. / (mat [0][0] * s0 + mat [1][0] * s1 + mat [2][0] * s2);
532
533 inv [0][0] = invdet * s0;
534 inv [0][1] = invdet * s1;
535 inv [0][2] = invdet * s2;
536
537 inv [1][0] = invdet * (mat [2][0] * mat [1][2] - mat [2][2] * mat [1][0]);
538 inv [1][1] = invdet * (mat [2][2] * mat [0][0] - mat [2][0] * mat [0][2]);
539 inv [1][2] = invdet * (mat [1][0] * mat [0][2] - mat [1][2] * mat [0][0]);
540
541 inv [2][0] = invdet * (mat [2][1] * mat [1][0] - mat [2][0] * mat [1][1]);
542 inv [2][1] = invdet * (mat [2][0] * mat [0][1] - mat [2][1] * mat [0][0]);
543 inv [2][2] = invdet * (mat [1][1] * mat [0][0] - mat [1][0] * mat [0][1]);
544}
545
546static double
547mat_apply (double mat[3][3], int i, double x, double y)
548{
549 double v = mat [i][0] * x + mat [i][1] * y + mat [i][2];
550 double w = mat [2][0] * x + mat [2][1] * y + mat [2][2];
551
552 return v * (1. / w);
553}
554
555rxvt_img *
556rxvt_img::transform (double matrix[3][3])
557{
558 // find new offset
559 int ox = mat_apply (matrix, 0, x, y);
560 int oy = mat_apply (matrix, 1, x, y);
561
562 // calculate new pixel bounding box coordinates
563 double rmin[2], rmax[2];
564
565 for (int i = 0; i < 2; ++i)
566 {
567 double v;
568 v = mat_apply (matrix, i, 0, 0); rmin [i] = rmax [i] = v;
569 v = mat_apply (matrix, i, w, 0); min_it (rmin [i], v); max_it (rmax [i], v);
570 v = mat_apply (matrix, i, 0, h); min_it (rmin [i], v); max_it (rmax [i], v);
571 v = mat_apply (matrix, i, w, h); min_it (rmin [i], v); max_it (rmax [i], v);
572 }
573
574 int dx = floor (rmin [0]);
575 int dy = floor (rmin [1]);
576
577 int new_width = ceil (rmax [0] - dx);
578 int new_height = ceil (rmax [1] - dy);
579
580 double inv[3][3];
581 mat_invert (matrix, inv);
582
583 rxvt_img *img = new rxvt_img (s, format, ox - dx, oy - dy, new_width, new_height, repeat);
584 img->alloc ();
585
586 Display *dpy = s->display->dpy;
587 Picture src = src_picture ();
588 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
229 589
230 XTransform xfrm; 590 XTransform xfrm;
231 591
232 for (int i = 0; i < 3; ++i) 592 for (int i = 0; i < 3; ++i)
233 for (int j = 0; j < 3; ++j) 593 for (int j = 0; j < 3; ++j)
234 xfrm.matrix [i][j] = XDoubleToFixed (matrix [i * 3 + j]); 594 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
235 595
596 XRenderSetPictureFilter (dpy, src, "good", 0, 0);
236 XRenderSetPictureTransform (dpy, src, &xfrm); 597 XRenderSetPictureTransform (dpy, src, &xfrm);
237 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, new_width, new_height); 598 XRenderComposite (dpy, PictOpSrc, src, None, dst, dx, dy, 0, 0, 0, 0, new_width, new_height);
238 599
239 XRenderFreePicture (dpy, src); 600 XRenderFreePicture (dpy, src);
240 XRenderFreePicture (dpy, dst); 601 XRenderFreePicture (dpy, dst);
241 602
242 return img; 603 return img;
243} 604}
244 605
245rxvt_img * 606rxvt_img *
246rxvt_img::scale (int new_width, int new_height) 607rxvt_img::scale (int new_width, int new_height)
247{ 608{
609 if (w == new_width && h == new_height)
610 return clone ();
611
248 double matrix[9] = { 612 double matrix[3][3] = {
249 new_width / (double)w, 0, 0, 613 { new_width / (double)w, 0, 0 },
250 0, new_height / (double)h, 0, 614 { 0, new_height / (double)h, 0 },
251 0, 0, 1 615 { 0, 0, 1 }
252 }; 616 };
253 617
254 return transform (new_width, new_height, RepeatNormal, matrix); 618 int old_repeat_mode = repeat;
255} 619 repeat = RepeatPad; // not right, but xrender can't properly scale it seems
256 620
621 rxvt_img *img = transform (matrix);
622
623 repeat = old_repeat_mode;
624 img->repeat = repeat;
625
626 return img;
627}
628
257rxvt_img * 629rxvt_img *
630rxvt_img::rotate (int cx, int cy, double phi)
631{
632 double s = sin (phi);
633 double c = cos (phi);
634
635 double matrix[3][3] = {
636 //{ c, -s, cx - c * cx + s * cy },
637 //{ s, c, cy - s * cx - c * cy },
638 //{ 0, 0, 1 }
639 { c, -s, 0 },
640 { s, c, 0 },
641 { 0, 0, 1 }
642 };
643
644 move (-cx, -cy);
645 rxvt_img *img = transform (matrix);
646 move ( cx, cy);
647 img->move (cx, cy);
648
649 return img;
650}
651
652rxvt_img *
258rxvt_img::convert_to (XRenderPictFormat *new_format) 653rxvt_img::convert_format (XRenderPictFormat *new_format, const rxvt_color &bg)
259{ 654{
655 if (new_format == format)
656 return clone ();
657
260 rxvt_img *img = new rxvt_img (s, new_format, w, h); 658 rxvt_img *img = new rxvt_img (s, new_format, x, y, w, h, repeat);
659 img->alloc ();
261 660
262 Display *dpy = s->display->dpy; 661 Display *dpy = s->display->dpy;
263 Picture src = XRenderCreatePicture (dpy, pm, format, 0, 0); 662 Picture src = src_picture ();
264 Picture dst = XRenderCreatePicture (dpy, img->pm, new_format, 0, 0); 663 Picture dst = XRenderCreatePicture (dpy, img->pm, new_format, 0, 0);
664 int op = PictOpSrc;
265 665
666 if (format->direct.alphaMask && !new_format->direct.alphaMask)
667 {
668 // does it have to be that complicated
669 rgba c;
670 bg.get (c);
671
672 XRenderColor rc = { c.r, c.g, c.b, 0xffff };
673 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);
674
675 op = PictOpOver;
676 }
677
266 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 678 XRenderComposite (dpy, op, src, None, dst, 0, 0, 0, 0, 0, 0, w, h);
267 679
268 XRenderFreePicture (dpy, src); 680 XRenderFreePicture (dpy, src);
269 XRenderFreePicture (dpy, dst); 681 XRenderFreePicture (dpy, dst);
270 682
271 return img; 683 return img;
272} 684}
273 685
686rxvt_img *
687rxvt_img::blend (rxvt_img *img, double factor)
688{
689 rxvt_img *img2 = clone ();
690 Display *dpy = s->display->dpy;
691 Picture src = img->src_picture ();
692 Picture dst = XRenderCreatePicture (dpy, img2->pm, img2->format, 0, 0);
693 Picture mask = create_xrender_mask (dpy, img->pm, False, False);
694
695 XRenderColor mask_c;
696
697 mask_c.alpha = float_to_component (factor);
698 mask_c.red =
699 mask_c.green =
700 mask_c.blue = 0;
701 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
702
703 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, w, h);
704
705 XRenderFreePicture (dpy, src);
706 XRenderFreePicture (dpy, dst);
707 XRenderFreePicture (dpy, mask);
708
709 return img2;
710}
711
274#endif 712#endif
275 713

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines