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.100 by root, Mon Jul 2 02:01:41 2012 UTC

1/*----------------------------------------------------------------------*
2 * File: rxvtimg.C
3 *----------------------------------------------------------------------*
4 *
5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2012 Marc Lehmann <schmorp@schmorp.de>
7 * Copyright (c) 2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 *---------------------------------------------------------------------*/
23
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);
371} 478}
372 479
373void 480void
481rxvt_img::fill (const rgba &c, int x, int y, int w, int h)
482{
483 XRenderColor rc = { c.r, c.g, c.b, c.a };
484
485 Display *dpy = s->dpy;
486 Picture src = picture ();
487 XRenderFillRectangle (dpy, PictOpSrc, src, &rc, x, y, w, h);
488 XRenderFreePicture (dpy, src);
489}
490
491void
374rxvt_img::fill (const rgba &c) 492rxvt_img::fill (const rgba &c)
375{ 493{
376 XRenderColor rc = { c.r, c.g, c.b, c.a }; 494 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} 495}
383 496
384void 497void
385rxvt_img::add_alpha () 498rxvt_img::add_alpha ()
386{ 499{
387 if (format->direct.alphaMask) 500 if (format->direct.alphaMask)
388 return; 501 return;
389 502
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); 503 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 504
398 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 505 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
399 506
400 XRenderFreePicture (dpy, src); 507 rxvt_img *img = cc;
401 XRenderFreePicture (dpy, dst);
402 508
403 ::swap (img->ref, ref); 509 ::swap (img->ref, ref);
404 ::swap (img->pm , pm ); 510 ::swap (img->pm , pm );
405 511
406 delete img; 512 delete img;
… …
431rxvt_img::blur (int rh, int rv) 537rxvt_img::blur (int rh, int rv)
432{ 538{
433 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV)) 539 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))
434 return clone (); 540 return clone ();
435 541
436 Display *dpy = s->display->dpy; 542 Display *dpy = s->dpy;
437 int size = max (rh, rv) * 2 + 1; 543 int size = max (rh, rv) * 2 + 1;
438 nv *kernel = (nv *)malloc (size * sizeof (nv)); 544 nv *kernel = (nv *)malloc (size * sizeof (nv));
439 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 545 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
440 rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat); 546 rxvt_img *img = new_empty ();
441 img->alloc ();
442 547
443 XRenderPictureAttributes pa; 548 XRenderPictureAttributes pa;
444 pa.repeat = RepeatPad; 549 pa.repeat = RepeatPad;
445 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 550 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
446 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0); 551 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
… …
489 XRenderFreePicture (dpy, tmp); 594 XRenderFreePicture (dpy, tmp);
490 595
491 return img; 596 return img;
492} 597}
493 598
494static Picture 599ecb_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) 600extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
512{ 601{
513 int32_t x = clamp (c, cl0, cl1); 602 int32_t x = clamp (c, cl0, cl1);
514 c -= x; 603 c -= x;
515 xc = x; 604 xc = x;
516} 605}
517 606
518static bool 607ecb_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) 608extract (int32_t cl0, int32_t cl1, int32_t &r, int32_t &g, int32_t &b, int32_t &a, unsigned short &xr, unsigned short &xg, unsigned short &xb, unsigned short &xa)
520{ 609{
521 extract (cl0, cl1, r, xr); 610 extract (cl0, cl1, r, xr);
522 extract (cl0, cl1, g, xg); 611 extract (cl0, cl1, g, xg);
523 extract (cl0, cl1, b, xb); 612 extract (cl0, cl1, b, xb);
… …
529void 618void
530rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a) 619rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
531{ 620{
532 unshare (); 621 unshare ();
533 622
534 Display *dpy = s->display->dpy; 623 Display *dpy = s->dpy;
535 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 624 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
536 625
537 // loop should not be needed for brightness, as only -1..1 makes sense 626 // loop should not be needed for brightness, as only -1..1 makes sense
538 //while (r | g | b | a) 627 //while (r | g | b | a)
539 { 628 {
… …
563rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a) 652rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
564{ 653{
565 if (r < 0 || g < 0 || b < 0 || a < 0) 654 if (r < 0 || g < 0 || b < 0 || a < 0)
566 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n"); 655 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
567 656
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) 657 // premultiply (yeah, these are not exact, sue me or fix it)
573 r = (r * (a >> 8)) >> 8; 658 r = (r * (a >> 8)) >> 8;
574 g = (g * (a >> 8)) >> 8; 659 g = (g * (a >> 8)) >> 8;
575 b = (b * (a >> 8)) >> 8; 660 b = (b * (a >> 8)) >> 8;
576 661
577 Display *dpy = s->display->dpy; 662 composer cc (this);
663 rxvt_img *img = cc;
664 img->fill (rgba (0, 0, 0, 0));
578 665
579 Picture src = picture (); 666 cc.mask (true);
580 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
581 Picture mul = create_xrender_mask (dpy, pm, True, True);
582 667
583 //TODO: this operator does not yet implement some useful contrast 668 //TODO: this operator does not yet implement some useful contrast
584 while (r | g | b | a) 669 while (r | g | b | a)
585 { 670 {
586 unsigned short xr, xg, xb, xa; 671 unsigned short xr, xg, xb, xa;
587 XRenderColor mask_c; 672 XRenderColor mask_c;
588 673
589 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha)) 674 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
590 { 675 {
591 XRenderFillRectangle (dpy, PictOpSrc, mul, &mask_c, 0, 0, 1, 1); 676 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); 677 XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
593 } 678 }
594 } 679 }
595
596 XRenderFreePicture (dpy, mul);
597 XRenderFreePicture (dpy, dst);
598 XRenderFreePicture (dpy, src);
599 680
600 ::swap (img->ref, ref); 681 ::swap (img->ref, ref);
601 ::swap (img->pm , pm ); 682 ::swap (img->pm , pm );
602 683
603 delete img; 684 delete img;
… …
606void 687void
607rxvt_img::draw (rxvt_img *img, int op, nv mask) 688rxvt_img::draw (rxvt_img *img, int op, nv mask)
608{ 689{
609 unshare (); 690 unshare ();
610 691
611 Display *dpy = s->display->dpy; 692 composer cc (img, this);
612 Picture src = img->picture ();
613 Picture dst = picture ();
614 Picture mask_p = 0;
615 693
616 if (mask != 1.) 694 if (mask != 1.)
617 { 695 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 696
623 XRenderComposite (dpy, op, src, mask_p, dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h); 697 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} 698}
631 699
632rxvt_img * 700rxvt_img *
633rxvt_img::clone () 701rxvt_img::clone ()
634{ 702{
… …
639rxvt_img::reify () 707rxvt_img::reify ()
640{ 708{
641 if (x == 0 && y == 0 && w == ref->w && h == ref->h) 709 if (x == 0 && y == 0 && w == ref->w && h == ref->h)
642 return clone (); 710 return clone ();
643 711
644 Display *dpy = s->display->dpy; 712 Display *dpy = s->dpy;
645 713
646 // add an alpha channel if... 714 // add an alpha channel if...
647 bool alpha = !format->direct.alphaMask // pixmap has none yet 715 bool alpha = !format->direct.alphaMask // pixmap has none yet
648 && (x || y) // we need one because of non-zero offset 716 && (x || y) // we need one because of non-zero offset
649 && repeat == RepeatNone; // and we have no good pixels to fill with 717 && repeat == RepeatNone; // and we have no good pixels to fill with
650 718
651 rxvt_img *img = new rxvt_img (s, alpha ? find_alpha_format_for (dpy, format) : format, 0, 0, w, h, repeat); 719 composer cc (this, new rxvt_img (s, alpha ? find_alpha_format_for (s->dpy, format) : format,
652 img->alloc (); 720 0, 0, w, h, repeat));
653 721
654 Picture src = picture ();
655 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
656
657 if (alpha) 722 if (alpha)
658 { 723 {
659 XRenderColor rc = { 0, 0, 0, 0 }; 724 XRenderColor rc = { 0, 0, 0, 0 };
660 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles 725 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); 726 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
662 } 727 }
663 else 728 else
664 XRenderComposite (dpy, PictOpSrc, src, None, dst, -x, -y, 0, 0, 0, 0, w, h); 729 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
665 730
666 XRenderFreePicture (dpy, src);
667 XRenderFreePicture (dpy, dst);
668
669 return img; 731 return cc;
670} 732}
671 733
672rxvt_img * 734rxvt_img *
673rxvt_img::sub_rect (int x, int y, int width, int height) 735rxvt_img::sub_rect (int x, int y, int width, int height)
674{ 736{
… …
689 751
690 return img; 752 return img;
691} 753}
692 754
693rxvt_img * 755rxvt_img *
694rxvt_img::transform (nv matrix[3][3]) 756rxvt_img::transform (const nv matrix[3][3])
695{ 757{
758 return transform (mat3x3 (&matrix[0][0]));
759}
760
761rxvt_img *
762rxvt_img::transform (const nv *matrix)
763{
764 mat3x3 m (matrix);
765
696 // calculate new pixel bounding box coordinates 766 // calculate new pixel bounding box coordinates
697 nv r[2], rmin[2], rmax[2]; 767 nv rmin[2], rmax[2];
698
699 mat3x3 m (matrix);
700 768
701 for (int i = 0; i < 2; ++i) 769 for (int i = 0; i < 2; ++i)
702 { 770 {
703 nv v; 771 nv v;
704 772
705 v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v; r [i] = v; 773 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); 774 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); 775 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); 776 v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
709 } 777 }
710 778
… …
716 int ny = floor (rmin [1]); 784 int ny = floor (rmin [1]);
717 785
718 int new_width = ceil (rmax [0] - rmin [0]); 786 int new_width = ceil (rmax [0] - rmin [0]);
719 int new_height = ceil (rmax [1] - rmin [1]); 787 int new_height = ceil (rmax [1] - rmin [1]);
720 788
721 m = mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y); 789 mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
722 790
723 mat3x3 inv = m.invert (); 791 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 792
732 XTransform xfrm; 793 XTransform xfrm;
733 794
734 for (int i = 0; i < 3; ++i) 795 for (int i = 0; i < 3; ++i)
735 for (int j = 0; j < 3; ++j) 796 for (int j = 0; j < 3; ++j)
736 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]); 797 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
737 798
738 XRenderSetPictureFilter (dpy, src, "good", 0, 0); 799 XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
739 XRenderSetPictureTransform (dpy, src, &xfrm); 800 XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
740 XRenderComposite (dpy, PictOpSrc, src, None, dst, sx, sy, 0, 0, 0, 0, new_width, new_height); 801 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 802
752 XRenderFreePicture (dpy, src);
753 XRenderFreePicture (dpy, dst);
754
755 return img; 803 return cc;
756} 804}
757 805
758rxvt_img * 806rxvt_img *
759rxvt_img::scale (int new_width, int new_height) 807rxvt_img::scale (int new_width, int new_height)
760{ 808{
761 if (w == new_width && h == new_height) 809 if (w == new_width && h == new_height)
762 return clone (); 810 return clone ();
763 811
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; 812 int old_repeat_mode = repeat;
771 repeat = RepeatPad; // not right, but xrender can't properly scale it seems 813 repeat = RepeatPad; // not right, but xrender can't properly scale it seems
772 814
773 rxvt_img *img = transform (matrix); 815 rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
774 816
775 repeat = old_repeat_mode; 817 repeat = old_repeat_mode;
776 img->repeat = repeat; 818 img->repeat = repeat;
777 819
778 return img; 820 return img;
779} 821}
780 822
781rxvt_img * 823rxvt_img *
782rxvt_img::rotate (int cx, int cy, nv phi) 824rxvt_img::rotate (int cx, int cy, nv phi)
783{ 825{
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); 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 composer cc (this);
874
875 XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
876
877 for (int i = 0; i < nparams; ++i)
878 xparams [i] = XDoubleToFixed (params [i]);
879
880 XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
881
882 XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
883
884 return cc;
862} 885}
863 886
864#endif 887#endif
865 888

Diff Legend

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