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.112 by root, Tue Sep 17 18:31:32 2019 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 3 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->d->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 // the casts are needed in C++11 (see 8.5.1)
194 XRenderColor rc = {
195 (unsigned short)(c.r * c.a / 65535),
196 (unsigned short)(c.g * c.a / 65535),
197 (unsigned short)(c.b * c.a / 65535),
198 c.a
199 };
200 msk = XRenderCreateSolidFill (dpy, &rc);
201 ecb_assume (msk);
202 }
203
204 void fill (const rgba &c)
205 {
206 XRenderColor rc = {
207 (unsigned short)(c.r * c.a / 65535),
208 (unsigned short)(c.g * c.a / 65535),
209 (unsigned short)(c.b * c.a / 65535),
210 c.a
211 };
212
213 XRenderFillRectangle (dpy, PictOpSrc, msk, &rc, 0, 0, 1, 1);
214 }
215
216 operator rxvt_img *()
217 {
218 return dstimg;
219 }
220
221 ecb_noinline
222 ~composer ()
223 {
224 XRenderFreePicture (dpy, src);
225 XRenderFreePicture (dpy, dst);
226 if (msk) XRenderFreePicture (dpy, msk);
227 }
228 };
229}
131 230
132static XRenderPictFormat * 231static XRenderPictFormat *
133find_alpha_format_for (Display *dpy, XRenderPictFormat *format) 232find_alpha_format_for (Display *dpy, XRenderPictFormat *format)
134{ 233{
135 if (format->direct.alphaMask) 234 if (format->direct.alphaMask)
… …
148 // should be a very good fallback 247 // should be a very good fallback
149 return XRenderFindStandardFormat (dpy, PictStandardARGB32); 248 return XRenderFindStandardFormat (dpy, PictStandardARGB32);
150} 249}
151 250
152rxvt_img::rxvt_img (rxvt_screen *screen, XRenderPictFormat *format, int x, int y, int width, int height, int repeat) 251rxvt_img::rxvt_img (rxvt_screen *screen, XRenderPictFormat *format, int x, int y, int width, int height, int repeat)
153: s(screen), x(x), y(y), w(width), h(height), format(format), repeat(repeat), 252: d(screen->display), x(x), y(y), w(width), h(height), format(format), repeat(repeat),
154 pm(0), ref(0) 253 pm(0), ref(0)
155{ 254{
156} 255}
157 256
257rxvt_img::rxvt_img (rxvt_display *display, XRenderPictFormat *format, int x, int y, int width, int height, int repeat)
258: d(display), x(x), y(y), w(width), h(height), format(format), repeat(repeat),
259 pm(0), ref(0)
260{
261}
262
158rxvt_img::rxvt_img (const rxvt_img &img) 263rxvt_img::rxvt_img (const rxvt_img &img)
159: s(img.s), x(img.x), y(img.y), w(img.w), h(img.h), format(img.format), repeat(img.repeat), pm(img.pm), ref(img.ref) 264: d(img.d), x(img.x), y(img.y), w(img.w), h(img.h), format(img.format), repeat(img.repeat), pm(img.pm), ref(img.ref)
160{ 265{
161 ++ref->cnt; 266 ++ref->cnt;
162} 267}
163 268
164rxvt_img * 269rxvt_img *
165rxvt_img::new_from_root (rxvt_screen *s) 270rxvt_img::new_from_root (rxvt_screen *s)
166{ 271{
167 Display *dpy = s->display->dpy; 272 Display *dpy = s->dpy;
168 unsigned int root_pm_w, root_pm_h; 273 unsigned int root_pm_w, root_pm_h;
169 Pixmap root_pixmap = s->display->get_pixmap_property (s->display->xa[XA_XROOTPMAP_ID]); 274 Pixmap root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_XROOTPMAP_ID]);
170 if (root_pixmap == None) 275 if (root_pixmap == None)
171 root_pixmap = s->display->get_pixmap_property (s->display->xa[XA_ESETROOT_PMAP_ID]); 276 root_pixmap = s->display->get_pixmap_property (s->display->xa [XA_ESETROOT_PMAP_ID]);
172 277
173 if (root_pixmap == None) 278 if (root_pixmap == None)
174 return 0; 279 return 0;
175 280
176 Window wdummy; 281 Window wdummy;
… …
199# if HAVE_PIXBUF 304# if HAVE_PIXBUF
200 305
201rxvt_img * 306rxvt_img *
202rxvt_img::new_from_pixbuf (rxvt_screen *s, GdkPixbuf *pb) 307rxvt_img::new_from_pixbuf (rxvt_screen *s, GdkPixbuf *pb)
203{ 308{
204 Display *dpy = s->display->dpy; 309 Display *dpy = s->dpy;
205 310
206 int width = gdk_pixbuf_get_width (pb); 311 int width = gdk_pixbuf_get_width (pb);
207 int height = gdk_pixbuf_get_height (pb); 312 int height = gdk_pixbuf_get_height (pb);
208 313
209 if (width > 32767 || height > 32767) // well, we *could* upload in chunks 314 if (width > 32767 || height > 32767) // well, we *could* upload in chunks
… …
251 for (int y = 0; y < height; y++) 356 for (int y = 0; y < height; y++)
252 { 357 {
253 unsigned char *src = row; 358 unsigned char *src = row;
254 uint32_t *dst = (uint32_t *)line; 359 uint32_t *dst = (uint32_t *)line;
255 360
256 if (!pb_has_alpha)
257 for (int x = 0; x < width; x++) 361 for (int x = 0; x < width; x++)
258 { 362 {
259 uint8_t r = *src++; 363 uint8_t r = *src++;
260 uint8_t g = *src++; 364 uint8_t g = *src++;
261 uint8_t b = *src++; 365 uint8_t b = *src++;
366 uint8_t a = *src;
262 367
368 // this is done so it can be jump-free, but newer gcc's clone inner the loop
369 a = pb_has_alpha ? a : 255;
370 src += pb_has_alpha;
371
372 r = (r * a + 127) / 255;
373 g = (g * a + 127) / 255;
374 b = (b * a + 127) / 255;
375
263 uint32_t v = (255 << 24) | (r << 16) | (g << 8) | b; 376 uint32_t v = (a << 24) | (r << 16) | (g << 8) | b;
264 377
265 if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch) 378 if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch)
266 v = ecb_bswap32 (v); 379 v = ecb_bswap32 (v);
267 380
268 *dst++ = v; 381 *dst++ = v;
269 } 382 }
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 383
286 row += rowstride; 384 row += rowstride;
287 line += xi.bytes_per_line; 385 line += xi.bytes_per_line;
288 } 386 }
289 387
… …
304{ 402{
305 GError *err = 0; 403 GError *err = 0;
306 GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err); 404 GdkPixbuf *pb = gdk_pixbuf_new_from_file (filename, &err);
307 405
308 if (!pb) 406 if (!pb)
407 try
408 {
309 rxvt_fatal ("rxvt_img::new_from_file: %s\n", err->message); 409 rxvt_fatal ("rxvt_img::new_from_file: %s\n", err->message);
410 }
411 catch (...)
412 {
413 g_error_free (err);
414 throw;
415 }
310 416
311 rxvt_img *img = new_from_pixbuf (s, pb); 417 rxvt_img *img = new_from_pixbuf (s, pb);
312 418
313 g_object_unref (pb); 419 g_object_unref (pb);
314 420
… …
322{ 428{
323 if (--ref->cnt) 429 if (--ref->cnt)
324 return; 430 return;
325 431
326 if (pm && ref->ours) 432 if (pm && ref->ours)
327 XFreePixmap (s->display->dpy, pm); 433 XFreePixmap (d->dpy, pm);
328 434
329 delete ref; 435 delete ref;
330} 436}
331 437
332rxvt_img::~rxvt_img () 438rxvt_img::~rxvt_img ()
… …
335} 441}
336 442
337void 443void
338rxvt_img::alloc () 444rxvt_img::alloc ()
339{ 445{
340 pm = XCreatePixmap (s->display->dpy, s->display->root, w, h, format->depth); 446 pm = XCreatePixmap (d->dpy, d->root, w, h, format->depth);
341 ref = new pixref (w, h); 447 ref = new pixref (w, h);
448}
449
450rxvt_img *
451rxvt_img::new_empty ()
452{
453 rxvt_img *img = new rxvt_img (d, format, x, y, w, h, repeat);
454 img->alloc ();
455
456 return img;
342} 457}
343 458
344Picture 459Picture
345rxvt_img::picture () 460rxvt_img::picture ()
346{ 461{
347 Display *dpy = s->display->dpy; 462 Display *dpy = d->dpy;
348 463
349 XRenderPictureAttributes pa; 464 XRenderPictureAttributes pa;
350 pa.repeat = repeat; 465 pa.repeat = repeat;
351 Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 466 Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
352 467
… …
357rxvt_img::unshare () 472rxvt_img::unshare ()
358{ 473{
359 if (ref->cnt == 1 && ref->ours) 474 if (ref->cnt == 1 && ref->ours)
360 return; 475 return;
361 476
362 Pixmap pm2 = XCreatePixmap (s->display->dpy, s->display->root, ref->w, ref->h, format->depth); 477 Pixmap pm2 = XCreatePixmap (d->dpy, d->root, ref->w, ref->h, format->depth);
363 GC gc = XCreateGC (s->display->dpy, pm, 0, 0); 478 GC gc = XCreateGC (d->dpy, pm, 0, 0);
364 XCopyArea (s->display->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0); 479 XCopyArea (d->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);
365 XFreeGC (s->display->dpy, gc); 480 XFreeGC (d->dpy, gc);
366 481
367 destroy (); 482 destroy ();
368 483
369 pm = pm2; 484 pm = pm2;
370 ref = new pixref (ref->w, ref->h); 485 ref = new pixref (ref->w, ref->h);
371} 486}
372 487
373void 488void
489rxvt_img::fill (const rgba &c, int x, int y, int w, int h)
490{
491 XRenderColor rc = { c.r, c.g, c.b, c.a };
492
493 Display *dpy = d->dpy;
494 Picture src = picture ();
495 XRenderFillRectangle (dpy, PictOpSrc, src, &rc, x, y, w, h);
496 XRenderFreePicture (dpy, src);
497}
498
499void
374rxvt_img::fill (const rgba &c) 500rxvt_img::fill (const rgba &c)
375{ 501{
376 XRenderColor rc = { c.r, c.g, c.b, c.a }; 502 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} 503}
383 504
384void 505void
385rxvt_img::add_alpha () 506rxvt_img::add_alpha ()
386{ 507{
387 if (format->direct.alphaMask) 508 if (format->direct.alphaMask)
388 return; 509 return;
389 510
390 Display *dpy = s->display->dpy; 511 composer cc (this, new rxvt_img (d, find_alpha_format_for (d->dpy, format), x, y, w, h, repeat));
391
392 rxvt_img *img = new rxvt_img (s, find_alpha_format_for (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 512
398 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 513 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
399 514
400 XRenderFreePicture (dpy, src); 515 rxvt_img *img = cc;
401 XRenderFreePicture (dpy, dst);
402 516
403 ::swap (img->ref, ref); 517 ::swap (img->ref, ref);
404 ::swap (img->pm , pm ); 518 ::swap (img->pm , pm );
405 519
406 delete img; 520 delete img;
… …
428} 542}
429 543
430rxvt_img * 544rxvt_img *
431rxvt_img::blur (int rh, int rv) 545rxvt_img::blur (int rh, int rv)
432{ 546{
433 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV)) 547 if (!(d->flags & DISPLAY_HAS_RENDER_CONV))
434 return clone (); 548 return clone ();
435 549
436 Display *dpy = s->display->dpy; 550 Display *dpy = d->dpy;
437 int size = max (rh, rv) * 2 + 1; 551 int size = max (rh, rv) * 2 + 1;
438 nv *kernel = (nv *)malloc (size * sizeof (nv)); 552 nv *kernel = (nv *)malloc (size * sizeof (nv));
439 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 553 XFixed *params = rxvt_temp_buf<XFixed> (size + 2);
440 rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat); 554 rxvt_img *img = new_empty ();
441 img->alloc ();
442 555
443 XRenderPictureAttributes pa; 556 XRenderPictureAttributes pa;
444 pa.repeat = RepeatPad; 557 pa.repeat = RepeatPad;
445 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 558 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
446 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0); 559 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
… …
480 0, 0, 593 0, 0,
481 w, h); 594 w, h);
482 } 595 }
483 596
484 free (kernel); 597 free (kernel);
485 free (params);
486 598
487 XRenderFreePicture (dpy, src); 599 XRenderFreePicture (dpy, src);
488 XRenderFreePicture (dpy, dst); 600 XRenderFreePicture (dpy, dst);
489 XRenderFreePicture (dpy, tmp); 601 XRenderFreePicture (dpy, tmp);
490 602
491 return img; 603 return img;
492} 604}
493 605
494static Picture 606rxvt_img *
495create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha) 607rxvt_img::muladd (nv mul, nv add)
496{ 608{
497 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8); 609 // STEP 1: double the image width, fill all odd columns with white (==1)
498 610
499 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8); 611 composer cc (this, new rxvt_img (d, 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 612
505 XFreePixmap (dpy, pixmap); 613 // why the hell does XRenderSetPictureTransform want a writable matrix :(
614 // that keeps us from just static const'ing this matrix.
615 XTransform h_double = {
616 0x08000, 0, 0,
617 0, 0x10000, 0,
618 0, 0, 0x10000
619 };
506 620
507 return mask; 621 XRenderSetPictureFilter (cc.dpy, cc.src, "nearest", 0, 0);
508} 622 XRenderSetPictureTransform (cc.dpy, cc.src, &h_double);
623 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
509 624
510static void 625 cc.mask (false, 2, 1);
626
627 static const XRenderColor c0 = { 0, 0, 0, 0 };
628 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c0, 0, 0, 1, 1);
629 static const XRenderColor c1 = { 65535, 65535, 65535, 65535 };
630 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c1, 1, 0, 1, 1);
631
632 Picture white = XRenderCreateSolidFill (cc.dpy, &c1);
633
634 XRenderComposite (cc.dpy, PictOpOver, white, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
635
636 XRenderFreePicture (cc.dpy, white);
637
638 // STEP 2: convolve the image with a 3x1 filter
639 // a 2x1 filter would obviously suffice, but given the total lack of specification
640 // for xrender, I expect different xrender implementations to randomly diverge.
641 // we also halve the image, and hope for the best (again, for lack of specs).
642 composer cc2 (cc.dstimg);
643
644 XFixed kernel [] = {
645 XDoubleToFixed (3), XDoubleToFixed (1),
646 XDoubleToFixed (0), XDoubleToFixed (mul), XDoubleToFixed (add)
647 };
648
649 XTransform h_halve = {
650 0x20000, 0, 0,
651 0, 0x10000, 0,
652 0, 0, 0x10000
653 };
654
655 XRenderSetPictureFilter (cc.dpy, cc2.src, "nearest", 0, 0);
656 XRenderSetPictureTransform (cc.dpy, cc2.src, &h_halve);
657 XRenderSetPictureFilter (cc.dpy, cc2.src, FilterConvolution, kernel, ecb_array_length (kernel));
658
659 XRenderComposite (cc.dpy, PictOpSrc, cc2.src, None, cc2.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
660
661 return cc2;
662}
663
664ecb_noinline static void
511extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc) 665extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
512{ 666{
513 int32_t x = clamp (c, cl0, cl1); 667 int32_t x = clamp (c, cl0, cl1);
514 c -= x; 668 c -= x;
515 xc = x; 669 xc = x;
516} 670}
517 671
518static bool 672ecb_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) 673extract (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{ 674{
521 extract (cl0, cl1, r, xr); 675 extract (cl0, cl1, r, xr);
522 extract (cl0, cl1, g, xg); 676 extract (cl0, cl1, g, xg);
523 extract (cl0, cl1, b, xb); 677 extract (cl0, cl1, b, xb);
… …
529void 683void
530rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a) 684rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
531{ 685{
532 unshare (); 686 unshare ();
533 687
534 Display *dpy = s->display->dpy; 688 Display *dpy = d->dpy;
535 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 689 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
536 690
537 // loop should not be needed for brightness, as only -1..1 makes sense 691 // loop should not be needed for brightness, as only -1..1 makes sense
538 //while (r | g | b | a) 692 //while (r | g | b | a)
539 { 693 {
… …
563rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a) 717rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
564{ 718{
565 if (r < 0 || g < 0 || b < 0 || a < 0) 719 if (r < 0 || g < 0 || b < 0 || a < 0)
566 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n"); 720 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
567 721
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) 722 // premultiply (yeah, these are not exact, sue me or fix it)
573 r = (r * (a >> 8)) >> 8; 723 r = (r * (a >> 8)) >> 8;
574 g = (g * (a >> 8)) >> 8; 724 g = (g * (a >> 8)) >> 8;
575 b = (b * (a >> 8)) >> 8; 725 b = (b * (a >> 8)) >> 8;
576 726
577 Display *dpy = s->display->dpy; 727 composer cc (this);
728 rxvt_img *img = cc;
729 img->fill (rgba (0, 0, 0, 0));
578 730
579 Picture src = picture (); 731 cc.mask (true);
580 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
581 Picture mul = create_xrender_mask (dpy, pm, True, True);
582 732
583 //TODO: this operator does not yet implement some useful contrast 733 //TODO: this operator does not yet implement some useful contrast
584 while (r | g | b | a) 734 while (r | g | b | a)
585 { 735 {
586 unsigned short xr, xg, xb, xa; 736 unsigned short xr, xg, xb, xa;
587 XRenderColor mask_c; 737 XRenderColor mask_c;
588 738
589 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha)) 739 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
590 { 740 {
591 XRenderFillRectangle (dpy, PictOpSrc, mul, &mask_c, 0, 0, 1, 1); 741 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); 742 XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
593 } 743 }
594 } 744 }
595
596 XRenderFreePicture (dpy, mul);
597 XRenderFreePicture (dpy, dst);
598 XRenderFreePicture (dpy, src);
599 745
600 ::swap (img->ref, ref); 746 ::swap (img->ref, ref);
601 ::swap (img->pm , pm ); 747 ::swap (img->pm , pm );
602 748
603 delete img; 749 delete img;
… …
606void 752void
607rxvt_img::draw (rxvt_img *img, int op, nv mask) 753rxvt_img::draw (rxvt_img *img, int op, nv mask)
608{ 754{
609 unshare (); 755 unshare ();
610 756
611 Display *dpy = s->display->dpy; 757 composer cc (img, this);
612 Picture src = img->picture ();
613 Picture dst = picture ();
614 Picture mask_p = 0;
615 758
616 if (mask != 1.) 759 if (mask != 1.)
617 { 760 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 761
623 XRenderComposite (dpy, op, src, mask_p, dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h); 762 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} 763}
631 764
632rxvt_img * 765rxvt_img *
633rxvt_img::clone () 766rxvt_img::clone ()
634{ 767{
… …
638rxvt_img * 771rxvt_img *
639rxvt_img::reify () 772rxvt_img::reify ()
640{ 773{
641 if (x == 0 && y == 0 && w == ref->w && h == ref->h) 774 if (x == 0 && y == 0 && w == ref->w && h == ref->h)
642 return clone (); 775 return clone ();
643
644 Display *dpy = s->display->dpy;
645 776
646 // add an alpha channel if... 777 // add an alpha channel if...
647 bool alpha = !format->direct.alphaMask // pixmap has none yet 778 bool alpha = !format->direct.alphaMask // pixmap has none yet
648 && (x || y) // we need one because of non-zero offset 779 && (x || y) // we need one because of non-zero offset
649 && repeat == RepeatNone; // and we have no good pixels to fill with 780 && repeat == RepeatNone; // and we have no good pixels to fill with
650 781
651 rxvt_img *img = new rxvt_img (s, alpha ? find_alpha_format_for (dpy, format) : format, 0, 0, w, h, repeat); 782 composer cc (this, new rxvt_img (d, alpha ? find_alpha_format_for (d->dpy, format) : format,
652 img->alloc (); 783 0, 0, w, h, repeat));
653 784
654 Picture src = picture (); 785 if (repeat == RepeatNone)
655 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
656
657 if (alpha)
658 { 786 {
659 XRenderColor rc = { 0, 0, 0, 0 }; 787 XRenderColor rc = { 0, 0, 0, 0 };
660 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles 788 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); 789 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
662 } 790 }
663 else 791 else
664 XRenderComposite (dpy, PictOpSrc, src, None, dst, -x, -y, 0, 0, 0, 0, w, h); 792 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
665 793
666 XRenderFreePicture (dpy, src);
667 XRenderFreePicture (dpy, dst);
668
669 return img; 794 return cc;
670} 795}
671 796
672rxvt_img * 797rxvt_img *
673rxvt_img::sub_rect (int x, int y, int width, int height) 798rxvt_img::sub_rect (int x, int y, int width, int height)
674{ 799{
… …
689 814
690 return img; 815 return img;
691} 816}
692 817
693rxvt_img * 818rxvt_img *
694rxvt_img::transform (nv matrix[3][3]) 819rxvt_img::transform (const nv matrix[3][3])
695{ 820{
821 return transform (mat3x3 (&matrix[0][0]));
822}
823
824rxvt_img *
825rxvt_img::transform (const nv *matrix)
826{
827 mat3x3 m (matrix);
828
696 // calculate new pixel bounding box coordinates 829 // calculate new pixel bounding box coordinates
697 nv r[2], rmin[2], rmax[2]; 830 nv rmin[2], rmax[2];
698
699 mat3x3 m (matrix);
700 831
701 for (int i = 0; i < 2; ++i) 832 for (int i = 0; i < 2; ++i)
702 { 833 {
703 nv v; 834 nv v;
704 835
705 v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v; r [i] = v; 836 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); 837 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); 838 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); 839 v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
709 } 840 }
710 841
… …
716 int ny = floor (rmin [1]); 847 int ny = floor (rmin [1]);
717 848
718 int new_width = ceil (rmax [0] - rmin [0]); 849 int new_width = ceil (rmax [0] - rmin [0]);
719 int new_height = ceil (rmax [1] - rmin [1]); 850 int new_height = ceil (rmax [1] - rmin [1]);
720 851
721 m = mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y); 852 mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
722 853
723 mat3x3 inv = m.invert (); 854 composer cc (this, new rxvt_img (d, 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 855
732 XTransform xfrm; 856 XTransform xfrm;
733 857
734 for (int i = 0; i < 3; ++i) 858 for (int i = 0; i < 3; ++i)
735 for (int j = 0; j < 3; ++j) 859 for (int j = 0; j < 3; ++j)
736 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]); 860 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
737 861
738 XRenderSetPictureFilter (dpy, src, "good", 0, 0); 862 XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
739 XRenderSetPictureTransform (dpy, src, &xfrm); 863 XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
740 XRenderComposite (dpy, PictOpSrc, src, None, dst, sx, sy, 0, 0, 0, 0, new_width, new_height); 864 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 865
752 XRenderFreePicture (dpy, src);
753 XRenderFreePicture (dpy, dst);
754
755 return img; 866 return cc;
756} 867}
757 868
758rxvt_img * 869rxvt_img *
759rxvt_img::scale (int new_width, int new_height) 870rxvt_img::scale (int new_width, int new_height)
760{ 871{
761 if (w == new_width && h == new_height) 872 if (w == new_width && h == new_height)
762 return clone (); 873 return clone ();
763 874
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; 875 int old_repeat_mode = repeat;
771 repeat = RepeatPad; // not right, but xrender can't properly scale it seems 876 repeat = RepeatPad; // not right, but xrender can't properly scale it seems
772 877
773 rxvt_img *img = transform (matrix); 878 rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
774 879
775 repeat = old_repeat_mode; 880 repeat = old_repeat_mode;
776 img->repeat = repeat; 881 img->repeat = repeat;
777 882
778 return img; 883 return img;
779} 884}
780 885
781rxvt_img * 886rxvt_img *
782rxvt_img::rotate (int cx, int cy, nv phi) 887rxvt_img::rotate (int cx, int cy, nv phi)
783{ 888{
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); 889 move (-cx, -cy);
800 rxvt_img *img = transform (matrix); 890 rxvt_img *img = transform (mat3x3::rotate (phi));
801 move ( cx, cy); 891 move ( cx, cy);
802 img->move (cx, cy); 892 img->move (cx, cy);
803 893
804 return img; 894 return img;
805} 895}
… …
808rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg) 898rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
809{ 899{
810 if (new_format == format) 900 if (new_format == format)
811 return clone (); 901 return clone ();
812 902
813 rxvt_img *img = new rxvt_img (s, new_format, x, y, w, h, repeat); 903 composer cc (this, new rxvt_img (d, new_format, x, y, w, h, repeat));
814 img->alloc ();
815 904
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; 905 int op = PictOpSrc;
820 906
821 if (format->direct.alphaMask && !new_format->direct.alphaMask) 907 if (format->direct.alphaMask && !new_format->direct.alphaMask)
822 { 908 {
823 // does it have to be that complicated 909 // does it have to be that complicated
824 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a }; 910 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
825 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h); 911 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
826 912
827 op = PictOpOver; 913 op = PictOpOver;
828 } 914 }
829 915
830 XRenderComposite (dpy, op, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 916 XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
831 917
832 XRenderFreePicture (dpy, src); 918 return cc;
833 XRenderFreePicture (dpy, dst); 919}
920
921rxvt_img *
922rxvt_img::tint (const rgba &c)
923{
924 composer cc (this);
925 cc.mask (true);
926 cc.fill (c);
927
928 XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
929
930 return cc;
931}
932
933rxvt_img *
934rxvt_img::shade (nv factor, rgba c)
935{
936 clamp_it (factor, -1., 1.);
937 factor++;
938
939 if (factor > 1)
940 {
941 c.r = c.r * (2 - factor);
942 c.g = c.g * (2 - factor);
943 c.b = c.b * (2 - factor);
944 }
945 else
946 {
947 c.r = c.r * factor;
948 c.g = c.g * factor;
949 c.b = c.b * factor;
950 }
951
952 rxvt_img *img = this->tint (c);
953
954 if (factor > 1)
955 {
956 c.a = 0xffff;
957 c.r =
958 c.g =
959 c.b = 0xffff * (factor - 1);
960
961 img->brightness (c.r, c.g, c.b, c.a);
962 }
834 963
835 return img; 964 return img;
836} 965}
837 966
838rxvt_img * 967rxvt_img *
839rxvt_img::blend (rxvt_img *img, nv factor) 968rxvt_img::filter (const char *name, int nparams, nv *params)
840{ 969{
841 rxvt_img *img2 = clone (); 970 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 971
847 XRenderColor mask_c; 972 XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
848 973
849 mask_c.alpha = float_to_component (factor); 974 for (int i = 0; i < nparams; ++i)
850 mask_c.red = 975 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 976
977 XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
978
855 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, w, h); 979 XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
856 980
857 XRenderFreePicture (dpy, src);
858 XRenderFreePicture (dpy, dst);
859 XRenderFreePicture (dpy, mask);
860
861 return img2; 981 return cc;
862} 982}
863 983
864#endif 984#endif
865 985

Diff Legend

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