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.98 by root, Sun Jun 17 21:58:18 2012 UTC

1/*----------------------------------------------------------------------*
2 * File: rxvtimg.C
3 *----------------------------------------------------------------------*
4 *
5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2012 Marc Lehmann <schmorp@schmorp.de>
7 * Copyright (c) 2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 *---------------------------------------------------------------------*/
23
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 x = 1, int y = 1)
176 {
177 Pixmap pixmap = XCreatePixmap (dpy, srcimg->pm, x, y, rgb ? 32 : 8);
178
179 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, rgb ? PictStandardARGB32 : PictStandardA8);
180 XRenderPictureAttributes pa;
181 pa.repeat = RepeatNormal;
182 pa.component_alpha = rgb;
183 msk = XRenderCreatePicture (dpy, pixmap, format, CPRepeat | CPComponentAlpha, &pa);
184
185 XFreePixmap (dpy, pixmap);
186
187 ecb_assume (msk);
188 }
189
190 // CreateSolidFill creates a very very very weird picture
191 void mask (const rgba &c)
192 {
193 XRenderColor rc = {
194 c.r * c.a / 65535,
195 c.g * c.a / 65535,
196 c.b * c.a / 65535,
197 c.a
198 };
199 msk = XRenderCreateSolidFill (dpy, &rc);
200 ecb_assume (msk);
201 }
202
203 void fill (const rgba &c)
204 {
205 XRenderColor rc = {
206 c.r * c.a / 65535,
207 c.g * c.a / 65535,
208 c.b * c.a / 65535,
209 c.a
210 };
211
212 XRenderFillRectangle (dpy, PictOpSrc, msk, &rc, 0, 0, 1, 1);
213 }
214
215 operator rxvt_img *()
216 {
217 return dstimg;
218 }
219
220 ecb_noinline
221 ~composer ()
222 {
223 XRenderFreePicture (dpy, src);
224 XRenderFreePicture (dpy, dst);
225 if (msk) XRenderFreePicture (dpy, msk);
226 }
227 };
228}
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
… …
259 uint8_t r = *src++; 357 uint8_t r = *src++;
260 uint8_t g = *src++; 358 uint8_t g = *src++;
261 uint8_t b = *src++; 359 uint8_t b = *src++;
262 360
263 uint32_t v = (255 << 24) | (r << 16) | (g << 8) | b; 361 uint32_t v = (255 << 24) | (r << 16) | (g << 8) | b;
264 362
265 if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch) 363 if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch)
266 v = ecb_bswap32 (v); 364 v = ecb_bswap32 (v);
267 365
268 *dst++ = v; 366 *dst++ = v;
269 } 367 }
… …
322{ 420{
323 if (--ref->cnt) 421 if (--ref->cnt)
324 return; 422 return;
325 423
326 if (pm && ref->ours) 424 if (pm && ref->ours)
327 XFreePixmap (s->display->dpy, pm); 425 XFreePixmap (s->dpy, pm);
328 426
329 delete ref; 427 delete ref;
330} 428}
331 429
332rxvt_img::~rxvt_img () 430rxvt_img::~rxvt_img ()
… …
335} 433}
336 434
337void 435void
338rxvt_img::alloc () 436rxvt_img::alloc ()
339{ 437{
340 pm = XCreatePixmap (s->display->dpy, s->display->root, w, h, format->depth); 438 pm = XCreatePixmap (s->dpy, s->display->root, w, h, format->depth);
341 ref = new pixref (w, h); 439 ref = new pixref (w, h);
440}
441
442rxvt_img *
443rxvt_img::new_empty ()
444{
445 rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat);
446 img->alloc ();
447
448 return img;
342} 449}
343 450
344Picture 451Picture
345rxvt_img::picture () 452rxvt_img::picture ()
346{ 453{
347 Display *dpy = s->display->dpy; 454 Display *dpy = s->dpy;
348 455
349 XRenderPictureAttributes pa; 456 XRenderPictureAttributes pa;
350 pa.repeat = repeat; 457 pa.repeat = repeat;
351 Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 458 Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
352 459
… …
357rxvt_img::unshare () 464rxvt_img::unshare ()
358{ 465{
359 if (ref->cnt == 1 && ref->ours) 466 if (ref->cnt == 1 && ref->ours)
360 return; 467 return;
361 468
362 Pixmap pm2 = XCreatePixmap (s->display->dpy, s->display->root, ref->w, ref->h, format->depth); 469 Pixmap pm2 = XCreatePixmap (s->dpy, s->display->root, ref->w, ref->h, format->depth);
363 GC gc = XCreateGC (s->display->dpy, pm, 0, 0); 470 GC gc = XCreateGC (s->dpy, pm, 0, 0);
364 XCopyArea (s->display->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0); 471 XCopyArea (s->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);
365 XFreeGC (s->display->dpy, gc); 472 XFreeGC (s->dpy, gc);
366 473
367 destroy (); 474 destroy ();
368 475
369 pm = pm2; 476 pm = pm2;
370 ref = new pixref (ref->w, ref->h); 477 ref = new pixref (ref->w, ref->h);
… …
373void 480void
374rxvt_img::fill (const rgba &c) 481rxvt_img::fill (const rgba &c)
375{ 482{
376 XRenderColor rc = { c.r, c.g, c.b, c.a }; 483 XRenderColor rc = { c.r, c.g, c.b, c.a };
377 484
378 Display *dpy = s->display->dpy; 485 Display *dpy = s->dpy;
379 Picture src = picture (); 486 Picture src = picture ();
380 XRenderFillRectangle (dpy, PictOpSrc, src, &rc, 0, 0, w, h); 487 XRenderFillRectangle (dpy, PictOpSrc, src, &rc, 0, 0, w, h);
381 XRenderFreePicture (dpy, src); 488 XRenderFreePicture (dpy, src);
382} 489}
383 490
… …
385rxvt_img::add_alpha () 492rxvt_img::add_alpha ()
386{ 493{
387 if (format->direct.alphaMask) 494 if (format->direct.alphaMask)
388 return; 495 return;
389 496
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); 497 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 498
398 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 499 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
399 500
400 XRenderFreePicture (dpy, src); 501 rxvt_img *img = cc;
401 XRenderFreePicture (dpy, dst);
402 502
403 ::swap (img->ref, ref); 503 ::swap (img->ref, ref);
404 ::swap (img->pm , pm ); 504 ::swap (img->pm , pm );
405 505
406 delete img; 506 delete img;
… …
431rxvt_img::blur (int rh, int rv) 531rxvt_img::blur (int rh, int rv)
432{ 532{
433 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV)) 533 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))
434 return clone (); 534 return clone ();
435 535
436 Display *dpy = s->display->dpy; 536 Display *dpy = s->dpy;
437 int size = max (rh, rv) * 2 + 1; 537 int size = max (rh, rv) * 2 + 1;
438 nv *kernel = (nv *)malloc (size * sizeof (nv)); 538 nv *kernel = (nv *)malloc (size * sizeof (nv));
439 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 539 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
440 rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat); 540 rxvt_img *img = new_empty ();
441 img->alloc ();
442 541
443 XRenderPictureAttributes pa; 542 XRenderPictureAttributes pa;
444 pa.repeat = RepeatPad; 543 pa.repeat = RepeatPad;
445 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 544 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
446 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0); 545 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
… …
489 XRenderFreePicture (dpy, tmp); 588 XRenderFreePicture (dpy, tmp);
490 589
491 return img; 590 return img;
492} 591}
493 592
494static Picture 593ecb_noinline static void
495create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha)
496{
497 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8);
498
499 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8);
500 XRenderPictureAttributes pa;
501 pa.repeat = RepeatNormal;
502 pa.component_alpha = component_alpha;
503 Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat | CPComponentAlpha, &pa);
504
505 XFreePixmap (dpy, pixmap);
506
507 return mask;
508}
509
510static void
511extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc) 594extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
512{ 595{
513 int32_t x = clamp (c, cl0, cl1); 596 int32_t x = clamp (c, cl0, cl1);
514 c -= x; 597 c -= x;
515 xc = x; 598 xc = x;
516} 599}
517 600
518static bool 601ecb_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) 602extract (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{ 603{
521 extract (cl0, cl1, r, xr); 604 extract (cl0, cl1, r, xr);
522 extract (cl0, cl1, g, xg); 605 extract (cl0, cl1, g, xg);
523 extract (cl0, cl1, b, xb); 606 extract (cl0, cl1, b, xb);
… …
529void 612void
530rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a) 613rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
531{ 614{
532 unshare (); 615 unshare ();
533 616
534 Display *dpy = s->display->dpy; 617 Display *dpy = s->dpy;
535 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 618 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
536 619
537 // loop should not be needed for brightness, as only -1..1 makes sense 620 // loop should not be needed for brightness, as only -1..1 makes sense
538 //while (r | g | b | a) 621 //while (r | g | b | a)
539 { 622 {
… …
563rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a) 646rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
564{ 647{
565 if (r < 0 || g < 0 || b < 0 || a < 0) 648 if (r < 0 || g < 0 || b < 0 || a < 0)
566 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n"); 649 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
567 650
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) 651 // premultiply (yeah, these are not exact, sue me or fix it)
573 r = (r * (a >> 8)) >> 8; 652 r = (r * (a >> 8)) >> 8;
574 g = (g * (a >> 8)) >> 8; 653 g = (g * (a >> 8)) >> 8;
575 b = (b * (a >> 8)) >> 8; 654 b = (b * (a >> 8)) >> 8;
576 655
577 Display *dpy = s->display->dpy; 656 composer cc (this);
657 rxvt_img *img = cc;
658 img->fill (rgba (0, 0, 0, 0));
578 659
579 Picture src = picture (); 660 cc.mask (true);
580 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
581 Picture mul = create_xrender_mask (dpy, pm, True, True);
582 661
583 //TODO: this operator does not yet implement some useful contrast 662 //TODO: this operator does not yet implement some useful contrast
584 while (r | g | b | a) 663 while (r | g | b | a)
585 { 664 {
586 unsigned short xr, xg, xb, xa; 665 unsigned short xr, xg, xb, xa;
587 XRenderColor mask_c; 666 XRenderColor mask_c;
588 667
589 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha)) 668 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
590 { 669 {
591 XRenderFillRectangle (dpy, PictOpSrc, mul, &mask_c, 0, 0, 1, 1); 670 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); 671 XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
593 } 672 }
594 } 673 }
595
596 XRenderFreePicture (dpy, mul);
597 XRenderFreePicture (dpy, dst);
598 XRenderFreePicture (dpy, src);
599 674
600 ::swap (img->ref, ref); 675 ::swap (img->ref, ref);
601 ::swap (img->pm , pm ); 676 ::swap (img->pm , pm );
602 677
603 delete img; 678 delete img;
… …
606void 681void
607rxvt_img::draw (rxvt_img *img, int op, nv mask) 682rxvt_img::draw (rxvt_img *img, int op, nv mask)
608{ 683{
609 unshare (); 684 unshare ();
610 685
611 Display *dpy = s->display->dpy; 686 composer cc (img, this);
612 Picture src = img->picture ();
613 Picture dst = picture ();
614 Picture mask_p = 0;
615 687
616 if (mask != 1.) 688 if (mask != 1.)
617 { 689 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 690
623 XRenderComposite (dpy, op, src, mask_p, dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h); 691 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} 692}
631 693
632rxvt_img * 694rxvt_img *
633rxvt_img::clone () 695rxvt_img::clone ()
634{ 696{
… …
639rxvt_img::reify () 701rxvt_img::reify ()
640{ 702{
641 if (x == 0 && y == 0 && w == ref->w && h == ref->h) 703 if (x == 0 && y == 0 && w == ref->w && h == ref->h)
642 return clone (); 704 return clone ();
643 705
644 Display *dpy = s->display->dpy; 706 Display *dpy = s->dpy;
645 707
646 // add an alpha channel if... 708 // add an alpha channel if...
647 bool alpha = !format->direct.alphaMask // pixmap has none yet 709 bool alpha = !format->direct.alphaMask // pixmap has none yet
648 && (x || y) // we need one because of non-zero offset 710 && (x || y) // we need one because of non-zero offset
649 && repeat == RepeatNone; // and we have no good pixels to fill with 711 && repeat == RepeatNone; // and we have no good pixels to fill with
650 712
651 rxvt_img *img = new rxvt_img (s, alpha ? find_alpha_format_for (dpy, format) : format, 0, 0, w, h, repeat); 713 composer cc (this, new rxvt_img (s, alpha ? find_alpha_format_for (s->dpy, format) : format,
652 img->alloc (); 714 0, 0, w, h, repeat));
653 715
654 Picture src = picture ();
655 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
656
657 if (alpha) 716 if (alpha)
658 { 717 {
659 XRenderColor rc = { 0, 0, 0, 0 }; 718 XRenderColor rc = { 0, 0, 0, 0 };
660 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles 719 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); 720 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
662 } 721 }
663 else 722 else
664 XRenderComposite (dpy, PictOpSrc, src, None, dst, -x, -y, 0, 0, 0, 0, w, h); 723 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
665 724
666 XRenderFreePicture (dpy, src);
667 XRenderFreePicture (dpy, dst);
668
669 return img; 725 return cc;
670} 726}
671 727
672rxvt_img * 728rxvt_img *
673rxvt_img::sub_rect (int x, int y, int width, int height) 729rxvt_img::sub_rect (int x, int y, int width, int height)
674{ 730{
… …
689 745
690 return img; 746 return img;
691} 747}
692 748
693rxvt_img * 749rxvt_img *
694rxvt_img::transform (nv matrix[3][3]) 750rxvt_img::transform (const nv matrix[3][3])
695{ 751{
752 return transform (mat3x3 (&matrix[0][0]));
753}
754
755rxvt_img *
756rxvt_img::transform (const nv *matrix)
757{
758 mat3x3 m (matrix);
759
696 // calculate new pixel bounding box coordinates 760 // calculate new pixel bounding box coordinates
697 nv r[2], rmin[2], rmax[2]; 761 nv rmin[2], rmax[2];
698
699 mat3x3 m (matrix);
700 762
701 for (int i = 0; i < 2; ++i) 763 for (int i = 0; i < 2; ++i)
702 { 764 {
703 nv v; 765 nv v;
704 766
705 v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v; r [i] = v; 767 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); 768 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); 769 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); 770 v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
709 } 771 }
710 772
… …
716 int ny = floor (rmin [1]); 778 int ny = floor (rmin [1]);
717 779
718 int new_width = ceil (rmax [0] - rmin [0]); 780 int new_width = ceil (rmax [0] - rmin [0]);
719 int new_height = ceil (rmax [1] - rmin [1]); 781 int new_height = ceil (rmax [1] - rmin [1]);
720 782
721 m = mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y); 783 mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
722 784
723 mat3x3 inv = m.invert (); 785 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 786
732 XTransform xfrm; 787 XTransform xfrm;
733 788
734 for (int i = 0; i < 3; ++i) 789 for (int i = 0; i < 3; ++i)
735 for (int j = 0; j < 3; ++j) 790 for (int j = 0; j < 3; ++j)
736 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]); 791 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
737 792
738 XRenderSetPictureFilter (dpy, src, "good", 0, 0); 793 XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
739 XRenderSetPictureTransform (dpy, src, &xfrm); 794 XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
740 XRenderComposite (dpy, PictOpSrc, src, None, dst, sx, sy, 0, 0, 0, 0, new_width, new_height); 795 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 796
752 XRenderFreePicture (dpy, src);
753 XRenderFreePicture (dpy, dst);
754
755 return img; 797 return cc;
756} 798}
757 799
758rxvt_img * 800rxvt_img *
759rxvt_img::scale (int new_width, int new_height) 801rxvt_img::scale (int new_width, int new_height)
760{ 802{
761 if (w == new_width && h == new_height) 803 if (w == new_width && h == new_height)
762 return clone (); 804 return clone ();
763 805
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; 806 int old_repeat_mode = repeat;
771 repeat = RepeatPad; // not right, but xrender can't properly scale it seems 807 repeat = RepeatPad; // not right, but xrender can't properly scale it seems
772 808
773 rxvt_img *img = transform (matrix); 809 rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
774 810
775 repeat = old_repeat_mode; 811 repeat = old_repeat_mode;
776 img->repeat = repeat; 812 img->repeat = repeat;
777 813
778 return img; 814 return img;
779} 815}
780 816
781rxvt_img * 817rxvt_img *
782rxvt_img::rotate (int cx, int cy, nv phi) 818rxvt_img::rotate (int cx, int cy, nv phi)
783{ 819{
784 nv s = sin (phi);
785 nv c = cos (phi);
786
787 nv matrix[3][3] = {
788#if 0 820#if 0
789 { c, -s, cx - c * cx + s * cy }, 821 { c, -s, cx - c * cx + s * cy },
790 { s, c, cy - s * cx - c * cy }, 822 { s, c, cy - s * cx - c * cy },
791 { 0, 0, 1 } 823 { 0, 0, 1 }
792#else
793 { c, -s, 0 },
794 { s, c, 0 },
795 { 0, 0, 1 }
796#endif 824#endif
797 };
798 825
799 move (-cx, -cy); 826 move (-cx, -cy);
800 rxvt_img *img = transform (matrix); 827 rxvt_img *img = transform (mat3x3::rotate (phi));
801 move ( cx, cy); 828 move ( cx, cy);
802 img->move (cx, cy); 829 img->move (cx, cy);
803 830
804 return img; 831 return img;
805} 832}
… …
808rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg) 835rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
809{ 836{
810 if (new_format == format) 837 if (new_format == format)
811 return clone (); 838 return clone ();
812 839
813 rxvt_img *img = new rxvt_img (s, new_format, x, y, w, h, repeat); 840 composer cc (this, new rxvt_img (s, new_format, x, y, w, h, repeat));
814 img->alloc ();
815 841
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; 842 int op = PictOpSrc;
820 843
821 if (format->direct.alphaMask && !new_format->direct.alphaMask) 844 if (format->direct.alphaMask && !new_format->direct.alphaMask)
822 { 845 {
823 // does it have to be that complicated 846 // does it have to be that complicated
824 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a }; 847 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
825 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h); 848 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
826 849
827 op = PictOpOver; 850 op = PictOpOver;
828 } 851 }
829 852
830 XRenderComposite (dpy, op, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 853 XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
831 854
832 XRenderFreePicture (dpy, src);
833 XRenderFreePicture (dpy, dst);
834
835 return img; 855 return cc;
836} 856}
837 857
838rxvt_img * 858rxvt_img *
839rxvt_img::blend (rxvt_img *img, nv factor) 859rxvt_img::tint (const rgba &c)
840{ 860{
841 rxvt_img *img2 = clone (); 861 composer cc (this);
842 Display *dpy = s->display->dpy; 862 cc.mask (true);
843 Picture src = img->picture (); 863 cc.fill (c);
844 Picture dst = XRenderCreatePicture (dpy, img2->pm, img2->format, 0, 0);
845 Picture mask = create_xrender_mask (dpy, img->pm, False, False);
846 864
847 XRenderColor mask_c;
848
849 mask_c.alpha = float_to_component (factor);
850 mask_c.red =
851 mask_c.green =
852 mask_c.blue = 0;
853 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
854
855 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, w, h); 865 XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
856 866
857 XRenderFreePicture (dpy, src);
858 XRenderFreePicture (dpy, dst);
859 XRenderFreePicture (dpy, mask);
860
861 return img2; 867 return cc;
868}
869
870rxvt_img *
871rxvt_img::filter (const char *name, int nparams, nv *params)
872{
873 rxvt_img *img = new_empty ();
874
875 composer cc (img);
876
877 XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
878
879 for (int i = 0; i < nparams; ++i)
880 xparams [i] = XDoubleToFixed (params [i]);
881
882 XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
883
884 XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
885
886 return cc;
862} 887}
863 888
864#endif 889#endif
865 890

Diff Legend

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