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.93 by root, Fri Jun 15 18:07:24 2012 UTC vs.
Revision 1.105 by sf-exg, Sat Jan 19 10:04:34 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 = (XFixed *)malloc ((size + 2) * sizeof (XFixed));
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);
… …
494 XRenderFreePicture (dpy, tmp); 587 XRenderFreePicture (dpy, tmp);
495 588
496 return img; 589 return img;
497} 590}
498 591
499static Picture 592rxvt_img *
500create_xrender_mask (Display *dpy, Drawable drawable, Bool argb, Bool component_alpha) 593rxvt_img::muladd (nv mul, nv add)
501{ 594{
502 Pixmap pixmap = XCreatePixmap (dpy, drawable, 1, 1, argb ? 32 : 8); 595 // STEP 1: double the image width, fill all odd columns with white (==1)
503 596
504 XRenderPictFormat *format = XRenderFindStandardFormat (dpy, argb ? PictStandardARGB32 : PictStandardA8); 597 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 598
510 XFreePixmap (dpy, pixmap); 599 // why the hell does XRenderSetPictureTransform want a writable matrix :(
600 // that keeps us from just static const'ing this matrix.
601 XTransform h_double = {
602 0x08000, 0, 0,
603 0, 0x10000, 0,
604 0, 0, 0x10000
605 };
511 606
512 return mask; 607 XRenderSetPictureFilter (cc.dpy, cc.src, "nearest", 0, 0);
513} 608 XRenderSetPictureTransform (cc.dpy, cc.src, &h_double);
609 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
514 610
515static void 611 cc.mask (false, 2, 1);
612
613 static const XRenderColor c0 = { 0, 0, 0, 0 };
614 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c0, 0, 0, 1, 1);
615 static const XRenderColor c1 = { 65535, 65535, 65535, 65535 };
616 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.msk, &c1, 1, 0, 1, 1);
617
618 Picture white = XRenderCreateSolidFill (cc.dpy, &c1);
619
620 XRenderComposite (cc.dpy, PictOpOver, white, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
621
622 XRenderFreePicture (cc.dpy, white);
623
624 // STEP 2: convolve the image with a 3x1 filter
625 // a 2x1 filter would obviously suffice, but given the total lack of specification
626 // for xrender, I expect different xrender implementations to randomly diverge.
627 // we also halve the image, and hope for the best (again, for lack of specs).
628 composer cc2 (cc.dstimg);
629
630 XFixed kernel [] = {
631 XDoubleToFixed (3), XDoubleToFixed (1),
632 XDoubleToFixed (0), XDoubleToFixed (mul), XDoubleToFixed (add)
633 };
634
635 XTransform h_halve = {
636 0x20000, 0, 0,
637 0, 0x10000, 0,
638 0, 0, 0x10000
639 };
640
641 XRenderSetPictureFilter (cc.dpy, cc2.src, "nearest", 0, 0);
642 XRenderSetPictureTransform (cc.dpy, cc2.src, &h_halve);
643 XRenderSetPictureFilter (cc.dpy, cc2.src, FilterConvolution, kernel, ecb_array_length (kernel));
644
645 XRenderComposite (cc.dpy, PictOpSrc, cc2.src, None, cc2.dst, 0, 0, 0, 0, 0, 0, w * 2, h);
646
647 return cc2;
648}
649
650ecb_noinline static void
516extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc) 651extract (int32_t cl0, int32_t cl1, int32_t &c, unsigned short &xc)
517{ 652{
518 int32_t x = clamp (c, cl0, cl1); 653 int32_t x = clamp (c, cl0, cl1);
519 c -= x; 654 c -= x;
520 xc = x; 655 xc = x;
521} 656}
522 657
523static bool 658ecb_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) 659extract (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{ 660{
526 extract (cl0, cl1, r, xr); 661 extract (cl0, cl1, r, xr);
527 extract (cl0, cl1, g, xg); 662 extract (cl0, cl1, g, xg);
528 extract (cl0, cl1, b, xb); 663 extract (cl0, cl1, b, xb);
… …
534void 669void
535rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a) 670rxvt_img::brightness (int32_t r, int32_t g, int32_t b, int32_t a)
536{ 671{
537 unshare (); 672 unshare ();
538 673
539 Display *dpy = s->display->dpy; 674 Display *dpy = s->dpy;
540 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0); 675 Picture dst = XRenderCreatePicture (dpy, pm, format, 0, 0);
541 676
542 // loop should not be needed for brightness, as only -1..1 makes sense 677 // loop should not be needed for brightness, as only -1..1 makes sense
543 //while (r | g | b | a) 678 //while (r | g | b | a)
544 { 679 {
… …
568rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a) 703rxvt_img::contrast (int32_t r, int32_t g, int32_t b, int32_t a)
569{ 704{
570 if (r < 0 || g < 0 || b < 0 || a < 0) 705 if (r < 0 || g < 0 || b < 0 || a < 0)
571 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n"); 706 rxvt_fatal ("rxvt_img::contrast does not support negative values.\n");
572 707
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) 708 // premultiply (yeah, these are not exact, sue me or fix it)
578 r = (r * (a >> 8)) >> 8; 709 r = (r * (a >> 8)) >> 8;
579 g = (g * (a >> 8)) >> 8; 710 g = (g * (a >> 8)) >> 8;
580 b = (b * (a >> 8)) >> 8; 711 b = (b * (a >> 8)) >> 8;
581 712
582 Display *dpy = s->display->dpy; 713 composer cc (this);
714 rxvt_img *img = cc;
715 img->fill (rgba (0, 0, 0, 0));
583 716
584 Picture src = picture (); 717 cc.mask (true);
585 Picture dst = XRenderCreatePicture (dpy, img->pm, format, 0, 0);
586 Picture mul = create_xrender_mask (dpy, pm, True, True);
587 718
588 //TODO: this operator does not yet implement some useful contrast 719 //TODO: this operator does not yet implement some useful contrast
589 while (r | g | b | a) 720 while (r | g | b | a)
590 { 721 {
591 unsigned short xr, xg, xb, xa; 722 unsigned short xr, xg, xb, xa;
592 XRenderColor mask_c; 723 XRenderColor mask_c;
593 724
594 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha)) 725 if (extract (0, 65535, r, g, b, a, mask_c.red, mask_c.green, mask_c.blue, mask_c.alpha))
595 { 726 {
596 XRenderFillRectangle (dpy, PictOpSrc, mul, &mask_c, 0, 0, 1, 1); 727 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); 728 XRenderComposite (cc.dpy, PictOpAdd, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
598 } 729 }
599 } 730 }
600
601 XRenderFreePicture (dpy, mul);
602 XRenderFreePicture (dpy, dst);
603 XRenderFreePicture (dpy, src);
604 731
605 ::swap (img->ref, ref); 732 ::swap (img->ref, ref);
606 ::swap (img->pm , pm ); 733 ::swap (img->pm , pm );
607 734
608 delete img; 735 delete img;
… …
611void 738void
612rxvt_img::draw (rxvt_img *img, int op, nv mask) 739rxvt_img::draw (rxvt_img *img, int op, nv mask)
613{ 740{
614 unshare (); 741 unshare ();
615 742
616 Display *dpy = s->display->dpy; 743 composer cc (img, this);
617 Picture src = img->picture ();
618 Picture dst = picture ();
619 Picture mask_p = 0;
620 744
621 if (mask != 1.) 745 if (mask != 1.)
622 { 746 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 747
628 XRenderComposite (dpy, op, src, mask_p, dst, x - img->x, y - img->y, 0, 0, 0, 0, w, h); 748 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} 749}
636 750
637rxvt_img * 751rxvt_img *
638rxvt_img::clone () 752rxvt_img::clone ()
639{ 753{
… …
643rxvt_img * 757rxvt_img *
644rxvt_img::reify () 758rxvt_img::reify ()
645{ 759{
646 if (x == 0 && y == 0 && w == ref->w && h == ref->h) 760 if (x == 0 && y == 0 && w == ref->w && h == ref->h)
647 return clone (); 761 return clone ();
648
649 Display *dpy = s->display->dpy;
650 762
651 // add an alpha channel if... 763 // add an alpha channel if...
652 bool alpha = !format->direct.alphaMask // pixmap has none yet 764 bool alpha = !format->direct.alphaMask // pixmap has none yet
653 && (x || y) // we need one because of non-zero offset 765 && (x || y) // we need one because of non-zero offset
654 && repeat == RepeatNone; // and we have no good pixels to fill with 766 && repeat == RepeatNone; // and we have no good pixels to fill with
655 767
656 rxvt_img *img = new rxvt_img (s, alpha ? find_alpha_format_for (dpy, format) : format, 0, 0, w, h, repeat); 768 composer cc (this, new rxvt_img (s, alpha ? find_alpha_format_for (s->dpy, format) : format,
657 img->alloc (); 769 0, 0, w, h, repeat));
658 770
659 Picture src = picture (); 771 if (repeat == RepeatNone)
660 Picture dst = XRenderCreatePicture (dpy, img->pm, img->format, 0, 0);
661
662 if (alpha)
663 { 772 {
664 XRenderColor rc = { 0, 0, 0, 0 }; 773 XRenderColor rc = { 0, 0, 0, 0 };
665 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h);//TODO: split into four fillrectangles 774 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); 775 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, 0, 0, 0, 0, x, y, ref->w, ref->h);
667 } 776 }
668 else 777 else
669 XRenderComposite (dpy, PictOpSrc, src, None, dst, -x, -y, 0, 0, 0, 0, w, h); 778 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, -x, -y, 0, 0, 0, 0, w, h);
670 779
671 XRenderFreePicture (dpy, src);
672 XRenderFreePicture (dpy, dst);
673
674 return img; 780 return cc;
675} 781}
676 782
677rxvt_img * 783rxvt_img *
678rxvt_img::sub_rect (int x, int y, int width, int height) 784rxvt_img::sub_rect (int x, int y, int width, int height)
679{ 785{
… …
694 800
695 return img; 801 return img;
696} 802}
697 803
698rxvt_img * 804rxvt_img *
699rxvt_img::transform (nv matrix[3][3]) 805rxvt_img::transform (const nv matrix[3][3])
700{ 806{
807 return transform (mat3x3 (&matrix[0][0]));
808}
809
810rxvt_img *
811rxvt_img::transform (const nv *matrix)
812{
813 mat3x3 m (matrix);
814
701 // calculate new pixel bounding box coordinates 815 // calculate new pixel bounding box coordinates
702 nv r[2], rmin[2], rmax[2]; 816 nv rmin[2], rmax[2];
703
704 mat3x3 m (matrix);
705 817
706 for (int i = 0; i < 2; ++i) 818 for (int i = 0; i < 2; ++i)
707 { 819 {
708 nv v; 820 nv v;
709 821
710 v = m.apply1 (i, 0+x, 0+y); rmin [i] = rmax [i] = v; r [i] = v; 822 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); 823 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); 824 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); 825 v = m.apply1 (i, w+x, h+y); min_it (rmin [i], v); max_it (rmax [i], v);
714 } 826 }
715 827
… …
721 int ny = floor (rmin [1]); 833 int ny = floor (rmin [1]);
722 834
723 int new_width = ceil (rmax [0] - rmin [0]); 835 int new_width = ceil (rmax [0] - rmin [0]);
724 int new_height = ceil (rmax [1] - rmin [1]); 836 int new_height = ceil (rmax [1] - rmin [1]);
725 837
726 m = mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y); 838 mat3x3 inv = (mat3x3::translate (-x, -y) * m * mat3x3::translate (x, y)).inverse ();
727 839
728 mat3x3 inv = m.invert (); 840 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 841
737 XTransform xfrm; 842 XTransform xfrm;
738 843
739 for (int i = 0; i < 3; ++i) 844 for (int i = 0; i < 3; ++i)
740 for (int j = 0; j < 3; ++j) 845 for (int j = 0; j < 3; ++j)
741 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]); 846 xfrm.matrix [i][j] = XDoubleToFixed (inv [i][j]);
742 847
743 XRenderSetPictureFilter (dpy, src, "good", 0, 0); 848 XRenderSetPictureFilter (cc.dpy, cc.src, "good", 0, 0);
744 XRenderSetPictureTransform (dpy, src, &xfrm); 849 XRenderSetPictureTransform (cc.dpy, cc.src, &xfrm);
745 XRenderComposite (dpy, PictOpSrc, src, None, dst, sx, sy, 0, 0, 0, 0, new_width, new_height); 850 XRenderComposite (cc.dpy, PictOpSrc, cc.src, None, cc.dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
746#if 1
747 {
748 XRenderColor rc = { 65535,0,0,65535 };
749 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, new_width, new_height);
750 }{
751 XRenderColor rc = { 0,0,0,65535 };
752 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 1, 1, new_width - 2, new_height - 2);
753 }
754 XRenderComposite (dpy, PictOpOver, src, None, dst, sx, sy, 0, 0, 0, 0, new_width, new_height);
755#endif
756 851
757 XRenderFreePicture (dpy, src);
758 XRenderFreePicture (dpy, dst);
759
760 return img; 852 return cc;
761} 853}
762 854
763rxvt_img * 855rxvt_img *
764rxvt_img::scale (int new_width, int new_height) 856rxvt_img::scale (int new_width, int new_height)
765{ 857{
766 if (w == new_width && h == new_height) 858 if (w == new_width && h == new_height)
767 return clone (); 859 return clone ();
768 860
769 nv matrix[3][3] = {
770 { new_width / (nv)w, 0, 0 },
771 { 0, new_height / (nv)h, 0 },
772 { 0, 0, 1 }
773 };
774
775 int old_repeat_mode = repeat; 861 int old_repeat_mode = repeat;
776 repeat = RepeatPad; // not right, but xrender can't properly scale it seems 862 repeat = RepeatPad; // not right, but xrender can't properly scale it seems
777 863
778 rxvt_img *img = transform (matrix); 864 rxvt_img *img = transform (mat3x3::scale (new_width / (nv)w, new_height / (nv)h));
779 865
780 repeat = old_repeat_mode; 866 repeat = old_repeat_mode;
781 img->repeat = repeat; 867 img->repeat = repeat;
782 868
783 return img; 869 return img;
784} 870}
785 871
786rxvt_img * 872rxvt_img *
787rxvt_img::rotate (int cx, int cy, nv phi) 873rxvt_img::rotate (int cx, int cy, nv phi)
788{ 874{
789 nv s = sin (phi);
790 nv c = cos (phi);
791
792 nv matrix[3][3] = {
793#if 0
794 { c, -s, cx - c * cx + s * cy },
795 { s, c, cy - s * cx - c * cy },
796 { 0, 0, 1 }
797#else
798 { c, -s, 0 },
799 { s, c, 0 },
800 { 0, 0, 1 }
801#endif
802 };
803
804 move (-cx, -cy); 875 move (-cx, -cy);
805 rxvt_img *img = transform (matrix); 876 rxvt_img *img = transform (mat3x3::rotate (phi));
806 move ( cx, cy); 877 move ( cx, cy);
807 img->move (cx, cy); 878 img->move (cx, cy);
808 879
809 return img; 880 return img;
810} 881}
… …
813rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg) 884rxvt_img::convert_format (XRenderPictFormat *new_format, const rgba &bg)
814{ 885{
815 if (new_format == format) 886 if (new_format == format)
816 return clone (); 887 return clone ();
817 888
818 rxvt_img *img = new rxvt_img (s, new_format, x, y, w, h, repeat); 889 composer cc (this, new rxvt_img (s, new_format, x, y, w, h, repeat));
819 img->alloc ();
820 890
821 Display *dpy = s->display->dpy;
822 Picture src = picture ();
823 Picture dst = XRenderCreatePicture (dpy, img->pm, new_format, 0, 0);
824 int op = PictOpSrc; 891 int op = PictOpSrc;
825 892
826 if (format->direct.alphaMask && !new_format->direct.alphaMask) 893 if (format->direct.alphaMask && !new_format->direct.alphaMask)
827 { 894 {
828 // does it have to be that complicated 895 // does it have to be that complicated
829 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a }; 896 XRenderColor rc = { bg.r, bg.g, bg.b, bg.a };
830 XRenderFillRectangle (dpy, PictOpSrc, dst, &rc, 0, 0, w, h); 897 XRenderFillRectangle (cc.dpy, PictOpSrc, cc.dst, &rc, 0, 0, w, h);
831 898
832 op = PictOpOver; 899 op = PictOpOver;
833 } 900 }
834 901
835 XRenderComposite (dpy, op, src, None, dst, 0, 0, 0, 0, 0, 0, w, h); 902 XRenderComposite (cc.dpy, op, cc.src, None, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
836 903
837 XRenderFreePicture (dpy, src); 904 return cc;
838 XRenderFreePicture (dpy, dst); 905}
906
907rxvt_img *
908rxvt_img::tint (const rgba &c)
909{
910 composer cc (this);
911 cc.mask (true);
912 cc.fill (c);
913
914 XRenderComposite (cc.dpy, PictOpSrc, cc.src, cc.msk, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
915
916 return cc;
917}
918
919rxvt_img *
920rxvt_img::shade (nv factor, rgba c)
921{
922 clamp_it (factor, -1., 1.);
923 factor++;
924
925 if (factor > 1)
926 {
927 c.r = c.r * (2 - factor);
928 c.g = c.g * (2 - factor);
929 c.b = c.b * (2 - factor);
930 }
931 else
932 {
933 c.r = c.r * factor;
934 c.g = c.g * factor;
935 c.b = c.b * factor;
936 }
937
938 rxvt_img *img = this->tint (c);
939
940 if (factor > 1)
941 {
942 c.a = 0xffff;
943 c.r =
944 c.g =
945 c.b = 0xffff * (factor - 1);
946
947 img->brightness (c.r, c.g, c.b, c.a);
948 }
839 949
840 return img; 950 return img;
841} 951}
842 952
843rxvt_img * 953rxvt_img *
844rxvt_img::blend (rxvt_img *img, nv factor) 954rxvt_img::filter (const char *name, int nparams, nv *params)
845{ 955{
846 rxvt_img *img2 = clone (); 956 composer cc (this);
847 Display *dpy = s->display->dpy;
848 Picture src = img->picture ();
849 Picture dst = XRenderCreatePicture (dpy, img2->pm, img2->format, 0, 0);
850 Picture mask = create_xrender_mask (dpy, img->pm, False, False);
851 957
852 XRenderColor mask_c; 958 XFixed *xparams = rxvt_temp_buf<XFixed> (nparams);
853 959
854 mask_c.alpha = float_to_component (factor); 960 for (int i = 0; i < nparams; ++i)
855 mask_c.red = 961 xparams [i] = XDoubleToFixed (params [i]);
856 mask_c.green =
857 mask_c.blue = 0;
858 XRenderFillRectangle (dpy, PictOpSrc, mask, &mask_c, 0, 0, 1, 1);
859 962
963 XRenderSetPictureFilter (cc.dpy, cc.src, name, xparams, nparams);
964
860 XRenderComposite (dpy, PictOpOver, src, mask, dst, 0, 0, 0, 0, 0, 0, w, h); 965 XRenderComposite (cc.dpy, PictOpSrc, cc.src, 0, cc.dst, 0, 0, 0, 0, 0, 0, w, h);
861 966
862 XRenderFreePicture (dpy, src);
863 XRenderFreePicture (dpy, dst);
864 XRenderFreePicture (dpy, mask);
865
866 return img2; 967 return cc;
867} 968}
868 969
869#endif 970#endif
870 971

Diff Legend

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