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

Diff Legend

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