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.106 by sf-exg, Fri Mar 1 09:34:40 2013 UTC

1/*----------------------------------------------------------------------*
2 * File: rxvtimg.C
3 *----------------------------------------------------------------------*
4 *
5 * All portions of code are copyright by their respective author/s.
6 * Copyright (c) 2012 Marc Lehmann <schmorp@schmorp.de>
7 * Copyright (c) 2012 Emanuele Giaquinta <e.giaquinta@glauco.it>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 *---------------------------------------------------------------------*/
23
1#include <string.h> 24#include <string.h>
2#include <math.h> 25#include <math.h>
3#include "../config.h" 26#include "../config.h"
4#include "rxvt.h" 27#include "rxvt.h"
5 28
… …
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->s->dpy;
170 src = srcimg->picture ();
171 dst = this->dstimg->picture ();
172 }
173
174 ecb_noinline
175 void mask (bool rgb = true, int w = 1, int h = 1)
176 {
177 Pixmap pixmap = XCreatePixmap (dpy, srcimg->pm, w, h, rgb ? 32 : 8);
178
179 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, rgb ? PictStandardARGB32 : PictStandardA8);
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 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 }
127 } 227 };
128 228}
129 ~pict ()
130 {
131 if (pic)
132 XRenderFreePicture (dpy, pic);
133 }
134};
135#endif
136 229
137static XRenderPictFormat * 230static XRenderPictFormat *
138find_alpha_format_for (Display *dpy, XRenderPictFormat *format) 231find_alpha_format_for (Display *dpy, XRenderPictFormat *format)
139{ 232{
140 if (format->direct.alphaMask) 233 if (format->direct.alphaMask)
… …
167} 260}
168 261
169rxvt_img * 262rxvt_img *
170rxvt_img::new_from_root (rxvt_screen *s) 263rxvt_img::new_from_root (rxvt_screen *s)
171{ 264{
172 Display *dpy = s->display->dpy; 265 Display *dpy = s->dpy;
173 unsigned int root_pm_w, root_pm_h; 266 unsigned int root_pm_w, root_pm_h;
174 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]);
175 if (root_pixmap == None) 268 if (root_pixmap == None)
176 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]);
177 270
178 if (root_pixmap == None) 271 if (root_pixmap == None)
179 return 0; 272 return 0;
180 273
181 Window wdummy; 274 Window wdummy;
… …
204# if HAVE_PIXBUF 297# if HAVE_PIXBUF
205 298
206rxvt_img * 299rxvt_img *
207rxvt_img::new_from_pixbuf (rxvt_screen *s, GdkPixbuf *pb) 300rxvt_img::new_from_pixbuf (rxvt_screen *s, GdkPixbuf *pb)
208{ 301{
209 Display *dpy = s->display->dpy; 302 Display *dpy = s->dpy;
210 303
211 int width = gdk_pixbuf_get_width (pb); 304 int width = gdk_pixbuf_get_width (pb);
212 int height = gdk_pixbuf_get_height (pb); 305 int height = gdk_pixbuf_get_height (pb);
213 306
214 if (width > 32767 || height > 32767) // well, we *could* upload in chunks 307 if (width > 32767 || height > 32767) // well, we *could* upload in chunks
… …
256 for (int y = 0; y < height; y++) 349 for (int y = 0; y < height; y++)
257 { 350 {
258 unsigned char *src = row; 351 unsigned char *src = row;
259 uint32_t *dst = (uint32_t *)line; 352 uint32_t *dst = (uint32_t *)line;
260 353
261 if (!pb_has_alpha)
262 for (int x = 0; x < width; x++) 354 for (int x = 0; x < width; x++)
263 { 355 {
264 uint8_t r = *src++; 356 uint8_t r = *src++;
265 uint8_t g = *src++; 357 uint8_t g = *src++;
266 uint8_t b = *src++; 358 uint8_t b = *src++;
359 uint8_t a = *src;
267 360
361 // this is done so it can be jump-free, but newer gcc's clone inner the loop
362 a = pb_has_alpha ? a : 255;
363 src += pb_has_alpha;
364
365 r = (r * a + 127) / 255;
366 g = (g * a + 127) / 255;
367 b = (b * a + 127) / 255;
368
268 uint32_t v = (255 << 24) | (r << 16) | (g << 8) | b; 369 uint32_t v = (a << 24) | (r << 16) | (g << 8) | b;
269 370
270 if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch) 371 if (ecb_big_endian () ? !byte_order_mismatch : byte_order_mismatch)
271 v = ecb_bswap32 (v); 372 v = ecb_bswap32 (v);
272 373
273 *dst++ = v; 374 *dst++ = v;
274 } 375 }
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 376
291 row += rowstride; 377 row += rowstride;
292 line += xi.bytes_per_line; 378 line += xi.bytes_per_line;
293 } 379 }
294 380
… …
327{ 413{
328 if (--ref->cnt) 414 if (--ref->cnt)
329 return; 415 return;
330 416
331 if (pm && ref->ours) 417 if (pm && ref->ours)
332 XFreePixmap (s->display->dpy, pm); 418 XFreePixmap (s->dpy, pm);
333 419
334 delete ref; 420 delete ref;
335} 421}
336 422
337rxvt_img::~rxvt_img () 423rxvt_img::~rxvt_img ()
… …
340} 426}
341 427
342void 428void
343rxvt_img::alloc () 429rxvt_img::alloc ()
344{ 430{
345 pm = XCreatePixmap (s->display->dpy, s->display->root, w, h, format->depth); 431 pm = XCreatePixmap (s->dpy, s->display->root, w, h, format->depth);
346 ref = new pixref (w, h); 432 ref = new pixref (w, h);
433}
434
435rxvt_img *
436rxvt_img::new_empty ()
437{
438 rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat);
439 img->alloc ();
440
441 return img;
347} 442}
348 443
349Picture 444Picture
350rxvt_img::picture () 445rxvt_img::picture ()
351{ 446{
352 Display *dpy = s->display->dpy; 447 Display *dpy = s->dpy;
353 448
354 XRenderPictureAttributes pa; 449 XRenderPictureAttributes pa;
355 pa.repeat = repeat; 450 pa.repeat = repeat;
356 Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 451 Picture pic = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
357 452
… …
362rxvt_img::unshare () 457rxvt_img::unshare ()
363{ 458{
364 if (ref->cnt == 1 && ref->ours) 459 if (ref->cnt == 1 && ref->ours)
365 return; 460 return;
366 461
367 Pixmap pm2 = XCreatePixmap (s->display->dpy, s->display->root, ref->w, ref->h, format->depth); 462 Pixmap pm2 = XCreatePixmap (s->dpy, s->display->root, ref->w, ref->h, format->depth);
368 GC gc = XCreateGC (s->display->dpy, pm, 0, 0); 463 GC gc = XCreateGC (s->dpy, pm, 0, 0);
369 XCopyArea (s->display->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0); 464 XCopyArea (s->dpy, pm, pm2, gc, 0, 0, ref->w, ref->h, 0, 0);
370 XFreeGC (s->display->dpy, gc); 465 XFreeGC (s->dpy, gc);
371 466
372 destroy (); 467 destroy ();
373 468
374 pm = pm2; 469 pm = pm2;
375 ref = new pixref (ref->w, ref->h); 470 ref = new pixref (ref->w, ref->h);
376} 471}
377 472
378void 473void
474rxvt_img::fill (const rgba &c, int x, int y, int w, int h)
475{
476 XRenderColor rc = { c.r, c.g, c.b, c.a };
477
478 Display *dpy = s->dpy;
479 Picture src = picture ();
480 XRenderFillRectangle (dpy, PictOpSrc, src, &rc, x, y, w, h);
481 XRenderFreePicture (dpy, src);
482}
483
484void
379rxvt_img::fill (const rgba &c) 485rxvt_img::fill (const rgba &c)
380{ 486{
381 XRenderColor rc = { c.r, c.g, c.b, c.a }; 487 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} 488}
388 489
389void 490void
390rxvt_img::add_alpha () 491rxvt_img::add_alpha ()
391{ 492{
392 if (format->direct.alphaMask) 493 if (format->direct.alphaMask)
393 return; 494 return;
394 495
395 Display *dpy = s->display->dpy;
396
397 rxvt_img *img = new rxvt_img (s, find_alpha_format_for (dpy, format), x, y, w, h, repeat); 496 composer cc (this, new rxvt_img (s, find_alpha_format_for (s->dpy, format), x, y, w, h, repeat));
398 img->alloc ();
399
400 Picture src = picture ();
401 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
402 497
403 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 498 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
404 499
405 XRenderFreePicture (dpy, src); 500 rxvt_img *img = cc;
406 XRenderFreePicture (dpy, dst);
407 501
408 ::swap (img->ref, ref); 502 ::swap (img->ref, ref);
409 ::swap (img->pm , pm ); 503 ::swap (img->pm , pm );
410 504
411 delete img; 505 delete img;
… …
436rxvt_img::blur (int rh, int rv) 530rxvt_img::blur (int rh, int rv)
437{ 531{
438 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV)) 532 if (!(s->display->flags & DISPLAY_HAS_RENDER_CONV))
439 return clone (); 533 return clone ();
440 534
441 Display *dpy = s->display->dpy; 535 Display *dpy = s->dpy;
442 int size = max (rh, rv) * 2 + 1; 536 int size = max (rh, rv) * 2 + 1;
443 nv *kernel = (nv *)malloc (size * sizeof (nv)); 537 nv *kernel = (nv *)malloc (size * sizeof (nv));
444 XFixed *params = (XFixed *)malloc ((size + 2) * sizeof (XFixed)); 538 XFixed *params = rxvt_temp_buf<XFixed> (size + 2);
445 rxvt_img *img = new rxvt_img (s, format, x, y, w, h, repeat); 539 rxvt_img *img = new_empty ();
446 img->alloc ();
447 540
448 XRenderPictureAttributes pa; 541 XRenderPictureAttributes pa;
449 pa.repeat = RepeatPad; 542 pa.repeat = RepeatPad;
450 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa); 543 Picture src = XRenderCreatePicture (dpy, pm, format, CPRepeat, &pa);
451 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0); 544 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
… …
485 0, 0, 578 0, 0,
486 w, h); 579 w, h);
487 } 580 }
488 581
489 free (kernel); 582 free (kernel);
490 free (params);
491 583
492 XRenderFreePicture (dpy, src); 584 XRenderFreePicture (dpy, src);
493 XRenderFreePicture (dpy, dst); 585 XRenderFreePicture (dpy, dst);
494 XRenderFreePicture (dpy, tmp); 586 XRenderFreePicture (dpy, tmp);
495 587
496 return img; 588 return img;
497} 589}
498 590
499static Picture 591rxvt_img *
500create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha) 592rxvt_img::muladd (nv mul, nv add)
501{ 593{
502 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8); 594 // STEP 1: double the image width, fill all odd columns with white (==1)
503 595
504 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8); 596 composer cc (this, new rxvt_img (s, format, 0, 0, w * 2, h, repeat));
505 XRenderPictureAttributes pa;
506 pa.repeat = RepeatNormal;
507 pa.component_alpha = component_alpha;
508 Picture mask = XRenderCreatePicture (dpy, pixmap, format, CPRepeat | CPComponentAlpha, &pa);
509 597
510 XFreePixmap (dpy, pixmap); 598 // why the hell does XRenderSetPictureTransform want a writable matrix :(
599 // that keeps us from just static const'ing this matrix.
600 XTransform h_double = {
601 0x08000, 0, 0,
602 0, 0x10000, 0,
603 0, 0, 0x10000
604 };
511 605
512 return mask; 606 XRenderSetPictureFilter (cc.dpy, cc.src, "nearest", 0, 0);
513} 607 XRenderSetPictureTransform (cc.dpy, cc.src, &h_double);
608 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
514 609
515static void 610 cc.mask (false, 2, 1);
611
612 static const XRenderColor c0 = { 0, 0, 0, 0 };
613 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c0, 0, 0, 1, 1);
614 static const XRenderColor c1 = { 65535, 65535, 65535, 65535 };
615 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c1, 1, 0, 1, 1);
616
617 Picture white = XRenderCreateSolidFill (cc.dpy, &c1);
618
619 XRenderComposite (cc.dpy, PictOpOver, white, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
620
621 XRenderFreePicture (cc.dpy, white);
622
623 // STEP 2: convolve the image with a 3x1 filter
624 // a 2x1 filter would obviously suffice, but given the total lack of specification
625 // for xrender, I expect different xrender implementations to randomly diverge.
626 // we also halve the image, and hope for the best (again, for lack of specs).
627 composer cc2 (cc.dstimg);
628
629 XFixed kernel [] = {
630 XDoubleToFixed (3), XDoubleToFixed (1),
631 XDoubleToFixed (0), XDoubleToFixed (mul), XDoubleToFixed (add)
632 };
633
634 XTransform h_halve = {
635 0x20000, 0, 0,
636 0, 0x10000, 0,
637 0, 0, 0x10000
638 };
639
640 XRenderSetPictureFilter (cc.dpy, cc2.src, "nearest", 0, 0);
641 XRenderSetPictureTransform (cc.dpy, cc2.src, &h_halve);
642 XRenderSetPictureFilter (cc.dpy, cc2.src, FilterConvolution, kernel, ecb_array_length (kernel));
643
644 XRenderComposite (cc.dpy, PictOpSrc, cc2.src, None, cc2.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
645
646 return cc2;
647}
648
649ecb_noinline static void
516extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc) 650extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
517{ 651{
518 int32_t x = clamp (c, cl0, cl1); 652 int32_t x = clamp (c, cl0, cl1);
519 c -= x; 653 c -= x;
520 xc = x; 654 xc = x;
521} 655}
522 656
523static bool 657ecb_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) 658extract (int32_t cl0, int32_t cl1, int32_t &r, int32_t &g, int32_t &b, int32_t &a, unsigned short &xr, unsigned short &xg, unsigned short &xb, unsigned short &xa)
525{ 659{
526 extract (cl0, cl1, r, xr); 660 extract (cl0, cl1, r, xr);
527 extract (cl0, cl1, g, xg); 661 extract (cl0, cl1, g, xg);
528 extract (cl0, cl1, b, xb); 662 extract (cl0, cl1, b, xb);
… …
534void 668void
535rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a) 669rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
536{ 670{
537 unshare (); 671 unshare ();
538 672
539 Display *dpy = s->display->dpy; 673 Display *dpy = s->dpy;
540 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 674 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
541 675
542 // loop should not be needed for brightness, as only -1..1 makes sense 676 // loop should not be needed for brightness, as only -1..1 makes sense
543 //while (r | g | b | a) 677 //while (r | g | b | a)
544 { 678 {
… …
568rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a) 702rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
569{ 703{
570 if (r < 0 || g < 0 || b < 0 || a < 0) 704 if (r < 0 || g < 0 || b < 0 || a < 0)
571 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n"); 705 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
572 706
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) 707 // premultiply (yeah, these are not exact, sue me or fix it)
578 r = (r * (a >> 8)) >> 8; 708 r = (r * (a >> 8)) >> 8;
579 g = (g * (a >> 8)) >> 8; 709 g = (g * (a >> 8)) >> 8;
580 b = (b * (a >> 8)) >> 8; 710 b = (b * (a >> 8)) >> 8;
581 711
582 Display *dpy = s->display->dpy; 712 composer cc (this);
713 rxvt_img *img = cc;
714 img->fill (rgba (0, 0, 0, 0));
583 715
584 Picture src = picture (); 716 cc.mask (true);
585 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
586 Picture mul = create_xrender_mask (dpy, pm, True, True);
587 717
588 //TODO: this operator does not yet implement some useful contrast 718 //TODO: this operator does not yet implement some useful contrast
589 while (r | g | b | a) 719 while (r | g | b | a)
590 { 720 {
591 unsigned short xr, xg, xb, xa; 721 unsigned short xr, xg, xb, xa;
592 XRenderColor mask_c; 722 XRenderColor mask_c;
593 723
594 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha)) 724 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
595 { 725 {
596 XRenderFillRectangle (dpy, PictOpSrc, mul, &mask_c, 0, 0, 1, 1); 726 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); 727 XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
598 } 728 }
599 } 729 }
600
601 XRenderFreePicture (dpy, mul);
602 XRenderFreePicture (dpy, dst);
603 XRenderFreePicture (dpy, src);
604 730
605 ::swap (img->ref, ref); 731 ::swap (img->ref, ref);
606 ::swap (img->pm , pm ); 732 ::swap (img->pm , pm );
607 733
608 delete img; 734 delete img;
… …
611void 737void
612rxvt_img::draw (rxvt_img *img, int op, nv mask) 738rxvt_img::draw (rxvt_img *img, int op, nv mask)
613{ 739{
614 unshare (); 740 unshare ();
615 741
616 Display *dpy = s->display->dpy; 742 composer cc (img, this);
617 Picture src = img->picture ();
618 Picture dst = picture ();
619 Picture mask_p = 0;
620 743
621 if (mask != 1.) 744 if (mask != 1.)
622 { 745 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 746
628 XRenderComposite (dpy, op, src, mask_p, dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h); 747 XRenderComposite (cc.dpy, op, cc.src, cc.msk, cc.dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h);
629
630 XRenderFreePicture (dpy, src);
631 XRenderFreePicture (dpy, dst);
632
633 if (mask_p)
634 XRenderFreePicture (dpy, mask_p);
635} 748}
636 749
637rxvt_img * 750rxvt_img *
638rxvt_img::clone () 751rxvt_img::clone ()
639{ 752{
… …
643rxvt_img * 756rxvt_img *
644rxvt_img::reify () 757rxvt_img::reify ()
645{ 758{
646 if (x == 0 && y == 0 && w == ref->w && h == ref->h) 759 if (x == 0 && y == 0 && w == ref->w && h == ref->h)
647 return clone (); 760 return clone ();
648
649 Display *dpy = s->display->dpy;
650 761
651 // add an alpha channel if... 762 // add an alpha channel if...
652 bool alpha = !format->direct.alphaMask // pixmap has none yet 763 bool alpha = !format->direct.alphaMask // pixmap has none yet
653 && (x || y) // we need one because of non-zero offset 764 && (x || y) // we need one because of non-zero offset
654 && repeat == RepeatNone; // and we have no good pixels to fill with 765 && repeat == RepeatNone; // and we have no good pixels to fill with
655 766
656 rxvt_img *img = new rxvt_img (s, alpha ? find_alpha_format_for (dpy, format) : format, 0, 0, w, h, repeat); 767 composer cc (this, new rxvt_img (s, alpha ? find_alpha_format_for (s->dpy, format) : format,
657 img->alloc (); 768 0, 0, w, h, repeat));
658 769
659 Picture src = picture (); 770 if (repeat == RepeatNone)
660 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
661
662 if (alpha)
663 { 771 {
664 XRenderColor rc = { 0, 0, 0, 0 }; 772 XRenderColor rc = { 0, 0, 0, 0 };
665 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles 773 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles
666 XRenderComposite (dpy, PictOpSrc, src, None, dst, 0, 0, 0, 0, x, y, ref->w, ref->h); 774 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
667 } 775 }
668 else 776 else
669 XRenderComposite (dpy, PictOpSrc, src, None, dst, -x, -y, 0, 0, 0, 0, w, h); 777 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
670 778
671 XRenderFreePicture (dpy, src);
672 XRenderFreePicture (dpy, dst);
673
674 return img; 779 return cc;
675} 780}
676 781
677rxvt_img * 782rxvt_img *
678rxvt_img::sub_rect (int x, int y, int width, int height) 783rxvt_img::sub_rect (int x, int y, int width, int height)
679{ 784{
… …
694 799
695 return img; 800 return img;
696} 801}
697 802
698rxvt_img * 803rxvt_img *
699rxvt_img::transform (nv matrix[3][3]) 804rxvt_img::transform (const nv matrix[3][3])
700{ 805{
806 return transform (mat3x3 (&matrix[0][0]));
807}
808
809rxvt_img *
810rxvt_img::transform (const nv *matrix)
811{
812 mat3x3 m (matrix);
813
701 // calculate new pixel bounding box coordinates 814 // calculate new pixel bounding box coordinates
702 nv r[2], rmin[2], rmax[2]; 815 nv rmin[2], rmax[2];
703
704 mat3x3 m (matrix);
705 816
706 for (int i = 0; i < 2; ++i) 817 for (int i = 0; i < 2; ++i)
707 { 818 {
708 nv v; 819 nv v;
709 820
710 v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v; r [i] = v; 821 v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v;
711 v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v); 822 v = m.apply1 (i, w+x, 0+y); min_it (rmin [i], v); max_it (rmax [i], v);
712 v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v); 823 v = m.apply1 (i, 0+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
713 v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v); 824 v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
714 } 825 }
715 826
… …
721 int ny = floor (rmin [1]); 832 int ny = floor (rmin [1]);
722 833
723 int new_width = ceil (rmax [0] - rmin [0]); 834 int new_width = ceil (rmax [0] - rmin [0]);
724 int new_height = ceil (rmax [1] - rmin [1]); 835 int new_height = ceil (rmax [1] - rmin [1]);
725 836
726 m = mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y); 837 mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
727 838
728 mat3x3 inv = m.invert (); 839 composer cc (this, new rxvt_img (s, 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 840
737 XTransform xfrm; 841 XTransform xfrm;
738 842
739 for (int i = 0; i < 3; ++i) 843 for (int i = 0; i < 3; ++i)
740 for (int j = 0; j < 3; ++j) 844 for (int j = 0; j < 3; ++j)
741 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]); 845 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
742 846
743 XRenderSetPictureFilter (dpy, src, "good", 0, 0); 847 XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
744 XRenderSetPictureTransform (dpy, src, &xfrm); 848 XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
745 XRenderComposite (dpy, PictOpSrc, src, None, dst, sx, sy, 0, 0, 0, 0, new_width, new_height); 849 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
746 850
747 XRenderFreePicture (dpy, src);
748 XRenderFreePicture (dpy, dst);
749
750 return img; 851 return cc;
751} 852}
752 853
753rxvt_img * 854rxvt_img *
754rxvt_img::scale (int new_width, int new_height) 855rxvt_img::scale (int new_width, int new_height)
755{ 856{
756 if (w == new_width && h == new_height) 857 if (w == new_width && h == new_height)
757 return clone (); 858 return clone ();
758 859
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; 860 int old_repeat_mode = repeat;
766 repeat = RepeatPad; // not right, but xrender can't properly scale it seems 861 repeat = RepeatPad; // not right, but xrender can't properly scale it seems
767 862
768 rxvt_img *img = transform (matrix); 863 rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
769 864
770 repeat = old_repeat_mode; 865 repeat = old_repeat_mode;
771 img->repeat = repeat; 866 img->repeat = repeat;
772 867
773 return img; 868 return img;
774} 869}
775 870
776rxvt_img * 871rxvt_img *
777rxvt_img::rotate (int cx, int cy, nv phi) 872rxvt_img::rotate (int cx, int cy, nv phi)
778{ 873{
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); 874 move (-cx, -cy);
795 rxvt_img *img = transform (matrix); 875 rxvt_img *img = transform (mat3x3::rotate (phi));
796 move ( cx, cy); 876 move ( cx, cy);
797 img->move (cx, cy); 877 img->move (cx, cy);
798 878
799 return img; 879 return img;
800} 880}
… …
803rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg) 883rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
804{ 884{
805 if (new_format == format) 885 if (new_format == format)
806 return clone (); 886 return clone ();
807 887
808 rxvt_img *img = new rxvt_img (s, new_format, x, y, w, h, repeat); 888 composer cc (this, new rxvt_img (s, new_format, x, y, w, h, repeat));
809 img->alloc ();
810 889
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; 890 int op = PictOpSrc;
815 891
816 if (format->direct.alphaMask && !new_format->direct.alphaMask) 892 if (format->direct.alphaMask && !new_format->direct.alphaMask)
817 { 893 {
818 // does it have to be that complicated 894 // does it have to be that complicated
819 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a }; 895 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
820 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h); 896 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
821 897
822 op = PictOpOver; 898 op = PictOpOver;
823 } 899 }
824 900
825 XRenderComposite (dpy, op, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 901 XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
826 902
827 XRenderFreePicture (dpy, src); 903 return cc;
828 XRenderFreePicture (dpy, dst); 904}
905
906rxvt_img *
907rxvt_img::tint (const rgba &c)
908{
909 composer cc (this);
910 cc.mask (true);
911 cc.fill (c);
912
913 XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
914
915 return cc;
916}
917
918rxvt_img *
919rxvt_img::shade (nv factor, rgba c)
920{
921 clamp_it (factor, -1., 1.);
922 factor++;
923
924 if (factor > 1)
925 {
926 c.r = c.r * (2 - factor);
927 c.g = c.g * (2 - factor);
928 c.b = c.b * (2 - factor);
929 }
930 else
931 {
932 c.r = c.r * factor;
933 c.g = c.g * factor;
934 c.b = c.b * factor;
935 }
936
937 rxvt_img *img = this->tint (c);
938
939 if (factor > 1)
940 {
941 c.a = 0xffff;
942 c.r =
943 c.g =
944 c.b = 0xffff * (factor - 1);
945
946 img->brightness (c.r, c.g, c.b, c.a);
947 }
829 948
830 return img; 949 return img;
831} 950}
832 951
833rxvt_img * 952rxvt_img *
834rxvt_img::blend (rxvt_img *img, nv factor) 953rxvt_img::filter (const char *name, int nparams, nv *params)
835{ 954{
836 rxvt_img *img2 = clone (); 955 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 956
842 XRenderColor mask_c; 957 XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
843 958
844 mask_c.alpha = float_to_component (factor); 959 for (int i = 0; i < nparams; ++i)
845 mask_c.red = 960 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 961
962 XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
963
850 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, w, h); 964 XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
851 965
852 XRenderFreePicture (dpy, src);
853 XRenderFreePicture (dpy, dst);
854 XRenderFreePicture (dpy, mask);
855
856 return img2; 966 return cc;
857} 967}
858 968
859#endif 969#endif
860 970

Diff Legend

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