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.92 by root, Fri Jun 15 18:05:15 2012 UTC vs.
Revision 1.106 by sf-exg, Fri Mar 1 09:34:40 2013 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
1#include <string.h> 24#include <string.h>
2#include <math.h> 25#include <math.h>
3#include "../config.h" 26#include "../config.h"
4#include "rxvt.h" 27#include "rxvt.h"
5 28
6#if HAVE_IMG 29#if HAVE_IMG
7 30
8typedef rxvt_img::nv nv; 31typedef rxvt_img::nv nv;
9 32
33namespace
34{
10struct mat3x3 35 struct mat3x3
11{
12 nv v[3][3];
13
14 mat3x3 ()
15 { 36 {
16 } 37 nv v[3][3];
17 38
18 mat3x3 (nv matrix[3][3]) 39 mat3x3 ()
19 { 40 {
41 }
42
43 mat3x3 (const nv *matrix)
44 {
20 memcpy (v, matrix, sizeof (v)); 45 memcpy (v, matrix, sizeof (v));
21 } 46 }
22 47
23 mat3x3 (nv v11, nv v12, nv v13, nv v21, nv v22, nv v23, nv v31, nv v32, nv v33) 48 mat3x3 (nv v11, nv v12, nv v13, nv v21, nv v22, nv v23, nv v31, nv v32, nv v33)
24 { 49 {
25 v[0][0] = v11; v[0][1] = v12; v[0][2] = v13; 50 v[0][0] = v11; v[0][1] = v12; v[0][2] = v13;
26 v[1][0] = v21; v[1][1] = v22; v[1][2] = v23; 51 v[1][0] = v21; v[1][1] = v22; v[1][2] = v23;
27 v[2][0] = v31; v[2][1] = v32; v[2][2] = v33; 52 v[2][0] = v31; v[2][1] = v32; v[2][2] = v33;
28 } 53 }
29 54
30 mat3x3 invert (); 55 mat3x3 inverse ();
31 56
32 nv *operator [](int i) { return &v[i][0]; } 57 nv *operator [](int i) { return &v[i][0]; }
33 const nv *operator [](int i) const { return &v[i][0]; } 58 const nv *operator [](int i) const { return &v[i][0]; }
34 59
60 operator const nv * () const { return &v[0][0]; }
61 operator nv * () { return &v[0][0]; }
62
35 // quite inefficient, hopefully gcc pulls the w calc out of any loops 63 // quite inefficient, hopefully gcc pulls the w calc out of any loops
36 nv apply1 (int i, nv x, nv y) 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 ()
37 { 81 {
38 mat3x3 &m = *this; 82 mat3x3 &m = *this;
83 mat3x3 inv;
39 84
40 nv v = m[i][0] * x + m[i][1] * y + m[i][2];
41 nv w = m[2][0] * x + m[2][1] * y + m[2][2]; 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];
42 88
43 return v * (1. / w); 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;
44 } 104 }
45 105
46 static mat3x3 translate (nv x, nv y);
47};
48
49mat3x3
50mat3x3::invert ()
51{
52 mat3x3 &m = *this;
53 mat3x3 inv;
54
55 nv s0 = m[2][2] * m[1][1] - m[2][1] * m[1][2];
56 nv s1 = m[2][1] * m[0][2] - m[2][2] * m[0][1];
57 nv s2 = m[1][2] * m[0][1] - m[1][1] * m[0][2];
58
59 nv invdet = 1. / (m[0][0] * s0 + m[1][0] * s1 + m[2][0] * s2);
60
61 inv[0][0] = invdet * s0;
62 inv[0][1] = invdet * s1;
63 inv[0][2] = invdet * s2;
64
65 inv[1][0] = invdet * (m[2][0] * m[1][2] - m[2][2] * m[1][0]);
66 inv[1][1] = invdet * (m[2][2] * m[0][0] - m[2][0] * m[0][2]);
67 inv[1][2] = invdet * (m[1][0] * m[0][2] - m[1][2] * m[0][0]);
68
69 inv[2][0] = invdet * (m[2][1] * m[1][0] - m[2][0] * m[1][1]);
70 inv[2][1] = invdet * (m[2][0] * m[0][1] - m[2][1] * m[0][0]);
71 inv[2][2] = invdet * (m[1][1] * m[0][0] - m[1][0] * m[0][1]);
72
73 return inv;
74}
75
76static mat3x3 106 static mat3x3
77operator *(const mat3x3 &a, const mat3x3 &b) 107 operator *(const mat3x3 &a, const mat3x3 &b)
78{
79 mat3x3 r;
80
81 for (int i = 0; i < 3; ++i)
82 for (int j = 0; j < 3; ++j)
83 r[i][j] = a[i][0] * b[0][j]
84 + a[i][1] * b[1][j]
85 + a[i][2] * b[2][j];
86
87 return r;
88}
89
90mat3x3
91mat3x3::translate (nv x, nv y)
92{
93 return mat3x3 (
94 1, 0, x,
95 0, 1, y,
96 0, 0, 1
97 );
98}
99
100#if 0
101struct pict
102{
103 Display *dpy;
104 Picture pic;
105
106 operator Picture () const
107 { 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
108 return pic; 117 return r;
109 } 118 }
110 119
111 pict () 120 mat3x3
112 : pic (0) 121 mat3x3::translate (nv x, nv y)
113 { 122 {
123 return mat3x3 (
124 1, 0, x,
125 0, 1, y,
126 0, 0, 1
127 );
114 } 128 }
115 129
116 pict (rxvt_img *img, XRenderPictFormat *format = 0) 130 mat3x3
117 : dpy (img->s->display->dpy) 131 mat3x3::scale (nv s, nv t)
118 { 132 {
119 XRenderPictureAttributes pa; 133 return mat3x3 (
120 pa.repeat = img->repeat; 134 s, 0, 0,
121 pic = XRenderCreatePicture (dpy, img->pm, format ? format : img->format, CPRepeat, &pa); 135 0, t, 0,
136 0, 0, 1
137 );
122 } 138 }
123 139
124 ~pict () 140 // clockwise
141 mat3x3
142 mat3x3::rotate (nv phi)
125 { 143 {
126 if (pic) 144 nv s = sin (phi);
127 XRenderFreePicture (dpy, pic); 145 nv c = cos (phi);
146
147 return mat3x3 (
148 c, -s, 0,
149 s, c, 0,
150 0, 0, 1
151 );
128 } 152 }
129}; 153
130#endif 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}
131 229
132static XRenderPictFormat * 230static XRenderPictFormat *
133find_alpha_format_for (Display *dpy, XRenderPictFormat *format) 231find_alpha_format_for (Display *dpy, XRenderPictFormat *format)
134{ 232{
135 if (format->direct.alphaMask) 233 if (format->direct.alphaMask)
… …
162} 260}
163 261
164rxvt_img * 262rxvt_img *
165rxvt_img::new_from_root (rxvt_screen *s) 263rxvt_img::new_from_root (rxvt_screen *s)
166{ 264{
167 Display *dpy = s->display->dpy; 265 Display *dpy = s->dpy;
168 unsigned int root_pm_w, root_pm_h; 266 unsigned int root_pm_w, root_pm_h;
169 Pixmap root_pixmap = s->display->get_pixmap_property (s->display->xa[XA_XROOTPMAP_ID]); 267 Pixmap root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_XROOTPMAP_ID]);
170 if (root_pixmap == None) 268 if (root_pixmap == None)
171 root_pixmap = s->display->get_pixmap_property (s->display->xa[XA_ESETROOT_PMAP_ID]); 269 root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_ESETROOT_PMAP_ID]);
172 270
173 if (root_pixmap == None) 271 if (root_pixmap == None)
174 return 0; 272 return 0;
175 273
176 Window wdummy; 274 Window wdummy;
… …
199# if HAVE_PIXBUF 297# if HAVE_PIXBUF
200 298
201rxvt_img * 299rxvt_img *
202rxvt_img::new_from_pixbuf (rxvt_screen *s, GdkPixbuf *pb) 300rxvt_img::new_from_pixbuf (rxvt_screen *s, GdkPixbuf *pb)
203{ 301{
204 Display *dpy = s->display->dpy; 302 Display *dpy = s->dpy;
205 303
206 int width = gdk_pixbuf_get_width (pb); 304 int width = gdk_pixbuf_get_width (pb);
207 int height = gdk_pixbuf_get_height (pb); 305 int height = gdk_pixbuf_get_height (pb);
208 306
209 if (width > 32767 || height > 32767) // well, we *could* upload in chunks 307 if (width > 32767 || height > 32767) // well, we *could* upload in chunks
… …
251 for (int y = 0; y < height; y++) 349 for (int y = 0; y < height; y++)
252 { 350 {
253 unsigned char *src = row; 351 unsigned char *src = row;
254 uint32_t *dst = (uint32_t *)line; 352 uint32_t *dst = (uint32_t *)line;
255 353
256 if (!pb_has_alpha)
257 for (int x = 0; x < width; x++) 354 for (int x = 0; x < width; x++)
258 { 355 {
259 uint8_t r = *src++; 356 uint8_t r = *src++;
260 uint8_t g = *src++; 357 uint8_t g = *src++;
261 uint8_t b = *src++; 358 uint8_t b = *src++;
359 uint8_t a = *src;
262 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
263 uint32_t v = (255 << 24) | (r << 16) | (g << 8) | b; 369 uint32_t v = (a << 24) | (r << 16) | (g << 8) | b;
264 370
265 if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch) 371 if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch)
266 v = ecb_bswap32 (v); 372 v = ecb_bswap32 (v);
267 373
268 *dst++ = v; 374 *dst++ = v;
269 } 375 }
270 else
271 for (int x = 0; x < width; x++)
272 {
273 uint32_t v = *(uint32_t *)src; src += 4;
274
275 if (ecb_big_endian ())
276 v = ecb_bswap32 (v);
277
278 v = ecb_rotl32 (v, 8); // abgr to bgra
279
280 if (!byte_order_mismatch)
281 v = ecb_bswap32 (v);
282
283 *dst++ = v;
284 }
285 376
286 row += rowstride; 377 row += rowstride;
287 line += xi.bytes_per_line; 378 line += xi.bytes_per_line;
288 } 379 }
289 380
… …
322{ 413{
323 if (--ref->cnt) 414 if (--ref->cnt)
324 return; 415 return;
325 416
326 if (pm && ref->ours) 417 if (pm && ref->ours)
327 XFreePixmap (s->display->dpy, pm); 418 XFreePixmap (s->dpy, pm);
328 419
329 delete ref; 420 delete ref;
330} 421}
331 422
332rxvt_img::~rxvt_img () 423rxvt_img::~rxvt_img ()
… …
335} 426}
336 427
337void 428void
338rxvt_img::alloc () 429rxvt_img::alloc ()
339{ 430{
340 pm = XCreatePixmap (s->display->dpy, s->display->root, w, h, format->depth); 431 pm = XCreatePixmap (s->dpy, s->display->root, w, h, format->depth);
341 ref = new pixref (w, h); 432 ref = new pixref (w, h);
433}
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;
342} 442}
343 443
344Picture 444Picture
345rxvt_img::picture () 445rxvt_img::picture ()
346{ 446{
347 Display *dpy = s->display->dpy; 447 Display *dpy = s->dpy;
348 448
349 XRenderPictureAttributes pa; 449 XRenderPictureAttributes pa;
350 pa.repeat = repeat; 450 pa.repeat = repeat;
351 Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 451 Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
352 452
… …
357rxvt_img::unshare () 457rxvt_img::unshare ()
358{ 458{
359 if (ref->cnt == 1 && ref->ours) 459 if (ref->cnt == 1 && ref->ours)
360 return; 460 return;
361 461
362 Pixmap pm2 = XCreatePixmap (s->display->dpy, s->display->root, ref->w, ref->h, format->depth); 462 Pixmap pm2 = XCreatePixmap (s->dpy, s->display->root, ref->w, ref->h, format->depth);
363 GC gc = XCreateGC (s->display->dpy, pm, 0, 0); 463 GC gc = XCreateGC (s->dpy, pm, 0, 0);
364 XCopyArea (s->display->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0); 464 XCopyArea (s->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);
365 XFreeGC (s->display->dpy, gc); 465 XFreeGC (s->dpy, gc);
366 466
367 destroy (); 467 destroy ();
368 468
369 pm = pm2; 469 pm = pm2;
370 ref = new pixref (ref->w, ref->h); 470 ref = new pixref (ref->w, ref->h);
371} 471}
372 472
373void 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
374rxvt_img::fill (const rgba &c) 485rxvt_img::fill (const rgba &c)
375{ 486{
376 XRenderColor rc = { c.r, c.g, c.b, c.a }; 487 fill (c, 0, 0, w, h);
377
378 Display *dpy = s->display->dpy;
379 Picture src = picture ();
380 XRenderFillRectangle (dpy, PictOpSrc, src, &rc, 0, 0, w, h);
381 XRenderFreePicture (dpy, src);
382} 488}
383 489
384void 490void
385rxvt_img::add_alpha () 491rxvt_img::add_alpha ()
386{ 492{
387 if (format->direct.alphaMask) 493 if (format->direct.alphaMask)
388 return; 494 return;
389 495
390 Display *dpy = s->display->dpy;
391
392 rxvt_img *img = new rxvt_img (s, find_alpha_format_for (dpy, format), x, y, w, h, repeat); 496 composer cc (this, new rxvt_img (s, find_alpha_format_for (s->dpy, format), x, y, w, h, repeat));
393 img->alloc ();
394
395 Picture src = picture ();
396 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
397 497
398 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 498 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
399 499
400 XRenderFreePicture (dpy, src); 500 rxvt_img *img = cc;
401 XRenderFreePicture (dpy, dst);
402 501
403 ::swap (img->ref, ref); 502 ::swap (img->ref, ref);
404 ::swap (img->pm , pm ); 503 ::swap (img->pm , pm );
405 504
406 delete img; 505 delete img;
… …
431rxvt_img::blur (int rh, int rv) 530rxvt_img::blur (int rh, int rv)
432{ 531{
433 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV)) 532 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))
434 return clone (); 533 return clone ();
435 534
436 Display *dpy = s->display->dpy; 535 Display *dpy = s->dpy;
437 int size = max (rh, rv) * 2 + 1; 536 int size = max (rh, rv) * 2 + 1;
438 nv *kernel = (nv *)malloc (size * sizeof (nv)); 537 nv *kernel = (nv *)malloc (size * sizeof (nv));
439 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 538 XFixed *params = rxvt_temp_buf<XFixed> (size + 2);
440 rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat); 539 rxvt_img *img = new_empty ();
441 img->alloc ();
442 540
443 XRenderPictureAttributes pa; 541 XRenderPictureAttributes pa;
444 pa.repeat = RepeatPad; 542 pa.repeat = RepeatPad;
445 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 543 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
446 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0); 544 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
… …
480 0, 0, 578 0, 0,
481 w, h); 579 w, h);
482 } 580 }
483 581
484 free (kernel); 582 free (kernel);
485 free (params);
486 583
487 XRenderFreePicture (dpy, src); 584 XRenderFreePicture (dpy, src);
488 XRenderFreePicture (dpy, dst); 585 XRenderFreePicture (dpy, dst);
489 XRenderFreePicture (dpy, tmp); 586 XRenderFreePicture (dpy, tmp);
490 587
491 return img; 588 return img;
492} 589}
493 590
494static Picture 591rxvt_img *
495create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha) 592rxvt_img::muladd (nv mul, nv add)
496{ 593{
497 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8); 594 // STEP 1: double the image width, fill all odd columns with white (==1)
498 595
499 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8); 596 composer cc (this, new rxvt_img (s, format, 0, 0, w * 2, h, repeat));
500 XRenderPictureAttributes pa;
501 pa.repeat = RepeatNormal;
502 pa.component_alpha = component_alpha;
503 Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat | CPComponentAlpha, &pa);
504 597
505 XFreePixmap (dpy, pixmap); 598 // why the hell does XRenderSetPictureTransform want a writable matrix :(
599 // that keeps us from just static const'ing this matrix.
600 XTransform h_double = {
601 0x08000, 0, 0,
602 0, 0x10000, 0,
603 0, 0, 0x10000
604 };
506 605
507 return mask; 606 XRenderSetPictureFilter (cc.dpy, cc.src, "nearest", 0, 0);
508} 607 XRenderSetPictureTransform (cc.dpy, cc.src, &h_double);
608 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
509 609
510static void 610 cc.mask (false, 2, 1);
611
612 static const XRenderColor c0 = { 0, 0, 0, 0 };
613 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c0, 0, 0, 1, 1);
614 static const XRenderColor c1 = { 65535, 65535, 65535, 65535 };
615 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c1, 1, 0, 1, 1);
616
617 Picture white = XRenderCreateSolidFill (cc.dpy, &c1);
618
619 XRenderComposite (cc.dpy, PictOpOver, white, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
620
621 XRenderFreePicture (cc.dpy, white);
622
623 // STEP 2: convolve the image with a 3x1 filter
624 // a 2x1 filter would obviously suffice, but given the total lack of specification
625 // for xrender, I expect different xrender implementations to randomly diverge.
626 // we also halve the image, and hope for the best (again, for lack of specs).
627 composer cc2 (cc.dstimg);
628
629 XFixed kernel [] = {
630 XDoubleToFixed (3), XDoubleToFixed (1),
631 XDoubleToFixed (0), XDoubleToFixed (mul), XDoubleToFixed (add)
632 };
633
634 XTransform h_halve = {
635 0x20000, 0, 0,
636 0, 0x10000, 0,
637 0, 0, 0x10000
638 };
639
640 XRenderSetPictureFilter (cc.dpy, cc2.src, "nearest", 0, 0);
641 XRenderSetPictureTransform (cc.dpy, cc2.src, &h_halve);
642 XRenderSetPictureFilter (cc.dpy, cc2.src, FilterConvolution, kernel, ecb_array_length (kernel));
643
644 XRenderComposite (cc.dpy, PictOpSrc, cc2.src, None, cc2.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
645
646 return cc2;
647}
648
649ecb_noinline static void
511extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc) 650extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
512{ 651{
513 int32_t x = clamp (c, cl0, cl1); 652 int32_t x = clamp (c, cl0, cl1);
514 c -= x; 653 c -= x;
515 xc = x; 654 xc = x;
516} 655}
517 656
518static bool 657ecb_noinline static bool
519extract (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) 658extract (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)
520{ 659{
521 extract (cl0, cl1, r, xr); 660 extract (cl0, cl1, r, xr);
522 extract (cl0, cl1, g, xg); 661 extract (cl0, cl1, g, xg);
523 extract (cl0, cl1, b, xb); 662 extract (cl0, cl1, b, xb);
… …
529void 668void
530rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a) 669rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
531{ 670{
532 unshare (); 671 unshare ();
533 672
534 Display *dpy = s->display->dpy; 673 Display *dpy = s->dpy;
535 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 674 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
536 675
537 // loop should not be needed for brightness, as only -1..1 makes sense 676 // loop should not be needed for brightness, as only -1..1 makes sense
538 //while (r | g | b | a) 677 //while (r | g | b | a)
539 { 678 {
… …
563rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a) 702rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
564{ 703{
565 if (r < 0 || g < 0 || b < 0 || a < 0) 704 if (r < 0 || g < 0 || b < 0 || a < 0)
566 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n"); 705 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
567 706
568 rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat);
569 img->alloc ();
570 img->fill (rgba (0, 0, 0, 0));
571
572 // premultiply (yeah, these are not exact, sue me or fix it) 707 // premultiply (yeah, these are not exact, sue me or fix it)
573 r = (r * (a >> 8)) >> 8; 708 r = (r * (a >> 8)) >> 8;
574 g = (g * (a >> 8)) >> 8; 709 g = (g * (a >> 8)) >> 8;
575 b = (b * (a >> 8)) >> 8; 710 b = (b * (a >> 8)) >> 8;
576 711
577 Display *dpy = s->display->dpy; 712 composer cc (this);
713 rxvt_img *img = cc;
714 img->fill (rgba (0, 0, 0, 0));
578 715
579 Picture src = picture (); 716 cc.mask (true);
580 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
581 Picture mul = create_xrender_mask (dpy, pm, True, True);
582 717
583 //TODO: this operator does not yet implement some useful contrast 718 //TODO: this operator does not yet implement some useful contrast
584 while (r | g | b | a) 719 while (r | g | b | a)
585 { 720 {
586 unsigned short xr, xg, xb, xa; 721 unsigned short xr, xg, xb, xa;
587 XRenderColor mask_c; 722 XRenderColor mask_c;
588 723
589 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha)) 724 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
590 { 725 {
591 XRenderFillRectangle (dpy, PictOpSrc, mul, &mask_c, 0, 0, 1, 1); 726 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &mask_c, 0, 0, 1, 1);
592 XRenderComposite (dpy, PictOpAdd, src, mul, dst, 0, 0, 0, 0, 0, 0, w, h); 727 XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
593 } 728 }
594 } 729 }
595
596 XRenderFreePicture (dpy, mul);
597 XRenderFreePicture (dpy, dst);
598 XRenderFreePicture (dpy, src);
599 730
600 ::swap (img->ref, ref); 731 ::swap (img->ref, ref);
601 ::swap (img->pm , pm ); 732 ::swap (img->pm , pm );
602 733
603 delete img; 734 delete img;
… …
606void 737void
607rxvt_img::draw (rxvt_img *img, int op, nv mask) 738rxvt_img::draw (rxvt_img *img, int op, nv mask)
608{ 739{
609 unshare (); 740 unshare ();
610 741
611 Display *dpy = s->display->dpy; 742 composer cc (img, this);
612 Picture src = img->picture ();
613 Picture dst = picture ();
614 Picture mask_p = 0;
615 743
616 if (mask != 1.) 744 if (mask != 1.)
617 { 745 cc.mask (rgba (0, 0, 0, float_to_component (mask)));
618 mask_p = create_xrender_mask (dpy, img->pm, False, False);
619 XRenderColor mask_c = { 0, 0, 0, float_to_component (mask) };
620 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
621 }
622 746
623 XRenderComposite (dpy, op, src, mask_p, dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h); 747 XRenderComposite (cc.dpy, op, cc.src, cc.msk, cc.dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h);
624
625 XRenderFreePicture (dpy, src);
626 XRenderFreePicture (dpy, dst);
627
628 if (mask_p)
629 XRenderFreePicture (dpy, mask_p);
630} 748}
631 749
632rxvt_img * 750rxvt_img *
633rxvt_img::clone () 751rxvt_img::clone ()
634{ 752{
… …
638rxvt_img * 756rxvt_img *
639rxvt_img::reify () 757rxvt_img::reify ()
640{ 758{
641 if (x == 0 && y == 0 && w == ref->w && h == ref->h) 759 if (x == 0 && y == 0 && w == ref->w && h == ref->h)
642 return clone (); 760 return clone ();
643
644 Display *dpy = s->display->dpy;
645 761
646 // add an alpha channel if... 762 // add an alpha channel if...
647 bool alpha = !format->direct.alphaMask // pixmap has none yet 763 bool alpha = !format->direct.alphaMask // pixmap has none yet
648 && (x || y) // we need one because of non-zero offset 764 && (x || y) // we need one because of non-zero offset
649 && repeat == RepeatNone; // and we have no good pixels to fill with 765 && repeat == RepeatNone; // and we have no good pixels to fill with
650 766
651 rxvt_img *img = new rxvt_img (s, alpha ? find_alpha_format_for (dpy, format) : format, 0, 0, w, h, repeat); 767 composer cc (this, new rxvt_img (s, alpha ? find_alpha_format_for (s->dpy, format) : format,
652 img->alloc (); 768 0, 0, w, h, repeat));
653 769
654 Picture src = picture (); 770 if (repeat == RepeatNone)
655 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
656
657 if (alpha)
658 { 771 {
659 XRenderColor rc = { 0, 0, 0, 0 }; 772 XRenderColor rc = { 0, 0, 0, 0 };
660 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles 773 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
661 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, x, y, ref->w, ref->h); 774 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
662 } 775 }
663 else 776 else
664 XRenderComposite (dpy, PictOpSrc, src, None, dst, -x, -y, 0, 0, 0, 0, w, h); 777 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
665 778
666 XRenderFreePicture (dpy, src);
667 XRenderFreePicture (dpy, dst);
668
669 return img; 779 return cc;
670} 780}
671 781
672rxvt_img * 782rxvt_img *
673rxvt_img::sub_rect (int x, int y, int width, int height) 783rxvt_img::sub_rect (int x, int y, int width, int height)
674{ 784{
… …
689 799
690 return img; 800 return img;
691} 801}
692 802
693rxvt_img * 803rxvt_img *
694rxvt_img::transform (nv matrix[3][3]) 804rxvt_img::transform (const nv matrix[3][3])
695{ 805{
806 return transform (mat3x3 (&matrix[0][0]));
807}
808
809rxvt_img *
810rxvt_img::transform (const nv *matrix)
811{
812 mat3x3 m (matrix);
813
696 // calculate new pixel bounding box coordinates 814 // calculate new pixel bounding box coordinates
697 nv r[2], rmin[2], rmax[2]; 815 nv rmin[2], rmax[2];
698
699 mat3x3 m (matrix);
700 816
701 for (int i = 0; i < 2; ++i) 817 for (int i = 0; i < 2; ++i)
702 { 818 {
703 nv v; 819 nv v;
704 820
705 v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v; r [i] = v; 821 v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v;
706 v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v); 822 v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v);
707 v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v); 823 v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
708 v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v); 824 v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
709 } 825 }
710 826
… …
716 int ny = floor (rmin [1]); 832 int ny = floor (rmin [1]);
717 833
718 int new_width = ceil (rmax [0] - rmin [0]); 834 int new_width = ceil (rmax [0] - rmin [0]);
719 int new_height = ceil (rmax [1] - rmin [1]); 835 int new_height = ceil (rmax [1] - rmin [1]);
720 836
721 m = mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y); 837 mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
722 838
723 mat3x3 inv = m.invert (); 839 composer cc (this, new rxvt_img (s, format, nx, ny, new_width, new_height, repeat));
724
725 rxvt_img *img = new rxvt_img (s, format, nx, ny, new_width, new_height, repeat);
726 img->alloc ();
727
728 Display *dpy = s->display->dpy;
729 Picture src = picture ();
730 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
731 840
732 XTransform xfrm; 841 XTransform xfrm;
733 842
734 for (int i = 0; i < 3; ++i) 843 for (int i = 0; i < 3; ++i)
735 for (int j = 0; j < 3; ++j) 844 for (int j = 0; j < 3; ++j)
736 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]); 845 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
737 846
738 XRenderSetPictureFilter (dpy, src, "good", 0, 0); 847 XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
739 XRenderSetPictureTransform (dpy, src, &xfrm); 848 XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
740 XRenderComposite (dpy, PictOpSrc, src, None, dst, sx, sy, 0, 0, 0, 0, new_width, new_height); 849 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
741#if 1
742 {
743 XRenderColor rc = { 65535,0,0,65535 };
744 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, new_width, new_height);
745 }{
746 XRenderColor rc = { 0,0,0,65535 };
747 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 1, 1, new_width - 2, new_height - 2);
748 }
749 XRenderComposite (dpy, PictOpOver, src, None, dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
750#endif
751 850
752 XRenderFreePicture (dpy, src);
753 XRenderFreePicture (dpy, dst);
754
755 return img; 851 return cc;
756} 852}
757 853
758rxvt_img * 854rxvt_img *
759rxvt_img::scale (int new_width, int new_height) 855rxvt_img::scale (int new_width, int new_height)
760{ 856{
761 if (w == new_width && h == new_height) 857 if (w == new_width && h == new_height)
762 return clone (); 858 return clone ();
763 859
764 nv matrix[3][3] = {
765 { new_width / (nv)w, 0, 0 },
766 { 0, new_height / (nv)h, 0 },
767 { 0, 0, 1 }
768 };
769
770 int old_repeat_mode = repeat; 860 int old_repeat_mode = repeat;
771 repeat = RepeatPad; // not right, but xrender can't properly scale it seems 861 repeat = RepeatPad; // not right, but xrender can't properly scale it seems
772 862
773 rxvt_img *img = transform (matrix); 863 rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
774 864
775 repeat = old_repeat_mode; 865 repeat = old_repeat_mode;
776 img->repeat = repeat; 866 img->repeat = repeat;
777 867
778 return img; 868 return img;
779} 869}
780 870
781rxvt_img * 871rxvt_img *
782rxvt_img::rotate (int cx, int cy, nv phi) 872rxvt_img::rotate (int cx, int cy, nv phi)
783{ 873{
784 nv s = sin (phi);
785 nv c = cos (phi);
786
787 nv matrix[3][3] = {
788#if 0
789 { c, -s, cx - c * cx + s * cy },
790 { s, c, cy - s * cx - c * cy },
791 { 0, 0, 1 }
792#else
793 { c, -s, 0 },
794 { s, c, 0 },
795 { 0, 0, 1 }
796#endif
797 };
798
799 move (-cx, -cy); 874 move (-cx, -cy);
800 rxvt_img *img = transform (matrix); 875 rxvt_img *img = transform (mat3x3::rotate (phi));
801 move ( cx, cy); 876 move ( cx, cy);
802 img->move (cx, cy); 877 img->move (cx, cy);
803 878
804 return img; 879 return img;
805} 880}
… …
808rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg) 883rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
809{ 884{
810 if (new_format == format) 885 if (new_format == format)
811 return clone (); 886 return clone ();
812 887
813 rxvt_img *img = new rxvt_img (s, new_format, x, y, w, h, repeat); 888 composer cc (this, new rxvt_img (s, new_format, x, y, w, h, repeat));
814 img->alloc ();
815 889
816 Display *dpy = s->display->dpy;
817 Picture src = picture ();
818 Picture dst = XRenderCreatePicture (dpy, img->pm, new_format, 0, 0);
819 int op = PictOpSrc; 890 int op = PictOpSrc;
820 891
821 if (format->direct.alphaMask && !new_format->direct.alphaMask) 892 if (format->direct.alphaMask && !new_format->direct.alphaMask)
822 { 893 {
823 // does it have to be that complicated 894 // does it have to be that complicated
824 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a }; 895 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
825 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h); 896 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
826 897
827 op = PictOpOver; 898 op = PictOpOver;
828 } 899 }
829 900
830 XRenderComposite (dpy, op, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 901 XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
831 902
832 XRenderFreePicture (dpy, src); 903 return cc;
833 XRenderFreePicture (dpy, dst); 904}
905
906rxvt_img *
907rxvt_img::tint (const rgba &c)
908{
909 composer cc (this);
910 cc.mask (true);
911 cc.fill (c);
912
913 XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
914
915 return cc;
916}
917
918rxvt_img *
919rxvt_img::shade (nv factor, rgba c)
920{
921 clamp_it (factor, -1., 1.);
922 factor++;
923
924 if (factor > 1)
925 {
926 c.r = c.r * (2 - factor);
927 c.g = c.g * (2 - factor);
928 c.b = c.b * (2 - factor);
929 }
930 else
931 {
932 c.r = c.r * factor;
933 c.g = c.g * factor;
934 c.b = c.b * factor;
935 }
936
937 rxvt_img *img = this->tint (c);
938
939 if (factor > 1)
940 {
941 c.a = 0xffff;
942 c.r =
943 c.g =
944 c.b = 0xffff * (factor - 1);
945
946 img->brightness (c.r, c.g, c.b, c.a);
947 }
834 948
835 return img; 949 return img;
836} 950}
837 951
838rxvt_img * 952rxvt_img *
839rxvt_img::blend (rxvt_img *img, nv factor) 953rxvt_img::filter (const char *name, int nparams, nv *params)
840{ 954{
841 rxvt_img *img2 = clone (); 955 composer cc (this);
842 Display *dpy = s->display->dpy;
843 Picture src = img->picture ();
844 Picture dst = XRenderCreatePicture (dpy, img2->pm, img2->format, 0, 0);
845 Picture mask = create_xrender_mask (dpy, img->pm, False, False);
846 956
847 XRenderColor mask_c; 957 XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
848 958
849 mask_c.alpha = float_to_component (factor); 959 for (int i = 0; i < nparams; ++i)
850 mask_c.red = 960 xparams [i] = XDoubleToFixed (params [i]);
851 mask_c.green =
852 mask_c.blue = 0;
853 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
854 961
962 XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
963
855 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, w, h); 964 XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
856 965
857 XRenderFreePicture (dpy, src);
858 XRenderFreePicture (dpy, dst);
859 XRenderFreePicture (dpy, mask);
860
861 return img2; 966 return cc;
862} 967}
863 968
864#endif 969#endif
865 970

Diff Legend

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