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.48 by root, Thu Jun 7 19:24:02 2012 UTC vs.
Revision 1.95 by root, Fri Jun 15 18:36:26 2012 UTC

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines