?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
winex11: Add helper function for copying brushes.
[wine/hacks.git] / dlls / winex11.drv / xrender.c
blobefa8d02abc440e03e133c0c03a5d89c0ae96b131
1 /*
2 * Functions to use the XRender extension
3 *
4 * Copyright 2001, 2002 Huw D M Davies for CodeWeavers
5 *
6 * Some parts also:
7 * Copyright 2000 Keith Packard, member of The XFree86 Project, Inc.
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library 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 GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <stdarg.h>
28 #include <string.h>
29 #include <stdlib.h>
30
31 #include "windef.h"
32 #include "winbase.h"
33 #include "x11drv.h"
34 #include "winternl.h"
35 #include "wine/library.h"
36 #include "wine/unicode.h"
37 #include "wine/debug.h"
38
39 int using_client_side_fonts = FALSE;
40
41 WINE_DEFAULT_DEBUG_CHANNEL(xrender);
42
43 #ifdef SONAME_LIBXRENDER
44
45 static BOOL X11DRV_XRender_Installed = FALSE;
46
47 #include <X11/Xlib.h>
48 #include <X11/extensions/Xrender.h>
49
50 #ifndef RepeatNone /* added in 0.10 */
51 #define RepeatNone 0
52 #define RepeatNormal 1
53 #define RepeatPad 2
54 #define RepeatReflect 3
55 #endif
56
57 #define MAX_FORMATS 10
58 typedef enum wine_xrformat
59 {
60 WXR_FORMAT_MONO,
61 WXR_FORMAT_GRAY,
62 WXR_FORMAT_X1R5G5B5,
63 WXR_FORMAT_X1B5G5R5,
64 WXR_FORMAT_R5G6B5,
65 WXR_FORMAT_B5G6R5,
66 WXR_FORMAT_R8G8B8,
67 WXR_FORMAT_B8G8R8,
68 WXR_FORMAT_A8R8G8B8,
69 WXR_FORMAT_X8R8G8B8,
70 } WXRFormat;
71
72 typedef struct wine_xrender_format_template
73 {
74 WXRFormat wxr_format;
75 unsigned int depth;
76 unsigned int alpha;
77 unsigned int alphaMask;
78 unsigned int red;
79 unsigned int redMask;
80 unsigned int green;
81 unsigned int greenMask;
82 unsigned int blue;
83 unsigned int blueMask;
84 } WineXRenderFormatTemplate;
85
86 static const WineXRenderFormatTemplate wxr_formats_template[] =
87 {
88 /* Format depth alpha mask red mask green mask blue mask*/
89 {WXR_FORMAT_MONO, 1, 0, 0x01, 0, 0, 0, 0, 0, 0 },
90 {WXR_FORMAT_GRAY, 8, 0, 0xff, 0, 0, 0, 0, 0, 0 },
91 {WXR_FORMAT_X1R5G5B5, 16, 0, 0, 10, 0x1f, 5, 0x1f, 0, 0x1f },
92 {WXR_FORMAT_X1B5G5R5, 16, 0, 0, 0, 0x1f, 5, 0x1f, 10, 0x1f },
93 {WXR_FORMAT_R5G6B5, 16, 0, 0, 11, 0x1f, 5, 0x3f, 0, 0x1f },
94 {WXR_FORMAT_B5G6R5, 16, 0, 0, 0, 0x1f, 5, 0x3f, 11, 0x1f },
95 {WXR_FORMAT_R8G8B8, 24, 0, 0, 16, 0xff, 8, 0xff, 0, 0xff },
96 {WXR_FORMAT_B8G8R8, 24, 0, 0, 0, 0xff, 8, 0xff, 16, 0xff },
97 {WXR_FORMAT_A8R8G8B8, 32, 24, 0xff, 16, 0xff, 8, 0xff, 0, 0xff },
98 {WXR_FORMAT_X8R8G8B8, 32, 0, 0, 16, 0xff, 8, 0xff, 0, 0xff }
99 };
100
101 typedef struct wine_xrender_format
102 {
103 WXRFormat format;
104 XRenderPictFormat *pict_format;
105 } WineXRenderFormat;
106
107 static WineXRenderFormat wxr_formats[MAX_FORMATS];
108 static int WineXRenderFormatsListSize = 0;
109 static WineXRenderFormat *default_format = NULL;
110
111 typedef struct
112 {
113 LOGFONTW lf;
114 XFORM xform;
115 SIZE devsize; /* size in device coords */
116 DWORD hash;
117 } LFANDSIZE;
118
119 #define INITIAL_REALIZED_BUF_SIZE 128
120
121 typedef enum { AA_None = 0, AA_Grey, AA_RGB, AA_BGR, AA_VRGB, AA_VBGR, AA_MAXVALUE } AA_Type;
122
123 typedef struct
124 {
125 GlyphSet glyphset;
126 WineXRenderFormat *font_format;
127 int nrealized;
128 BOOL *realized;
129 void **bitmaps;
130 XGlyphInfo *gis;
131 } gsCacheEntryFormat;
132
133 typedef struct
134 {
135 LFANDSIZE lfsz;
136 AA_Type aa_default;
137 gsCacheEntryFormat * format[AA_MAXVALUE];
138 INT count;
139 INT next;
140 } gsCacheEntry;
141
142 struct tagXRENDERINFO
143 {
144 int cache_index;
145 Picture pict;
146 };
147
148
149 static gsCacheEntry *glyphsetCache = NULL;
150 static DWORD glyphsetCacheSize = 0;
151 static INT lastfree = -1;
152 static INT mru = -1;
153
154 #define INIT_CACHE_SIZE 10
155
156 static int antialias = 1;
157
158 static void *xrender_handle;
159
160 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
161 MAKE_FUNCPTR(XRenderAddGlyphs)
162 MAKE_FUNCPTR(XRenderComposite)
163 MAKE_FUNCPTR(XRenderCompositeString8)
164 MAKE_FUNCPTR(XRenderCompositeString16)
165 MAKE_FUNCPTR(XRenderCompositeString32)
166 MAKE_FUNCPTR(XRenderCompositeText16)
167 MAKE_FUNCPTR(XRenderCreateGlyphSet)
168 MAKE_FUNCPTR(XRenderCreatePicture)
169 MAKE_FUNCPTR(XRenderFillRectangle)
170 MAKE_FUNCPTR(XRenderFindFormat)
171 MAKE_FUNCPTR(XRenderFindVisualFormat)
172 MAKE_FUNCPTR(XRenderFreeGlyphSet)
173 MAKE_FUNCPTR(XRenderFreePicture)
174 MAKE_FUNCPTR(XRenderSetPictureClipRectangles)
175 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
176 MAKE_FUNCPTR(XRenderSetPictureTransform)
177 #endif
178 MAKE_FUNCPTR(XRenderQueryExtension)
179 #undef MAKE_FUNCPTR
180
181 static CRITICAL_SECTION xrender_cs;
182 static CRITICAL_SECTION_DEBUG critsect_debug =
183 {
184 0, 0, &xrender_cs,
185 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
186 0, 0, { (DWORD_PTR)(__FILE__ ": xrender_cs") }
187 };
188 static CRITICAL_SECTION xrender_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
189
190 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
191 ( ( (ULONG)_x4 << 24 ) | \
192 ( (ULONG)_x3 << 16 ) | \
193 ( (ULONG)_x2 << 8 ) | \
194 (ULONG)_x1 )
195
196 #define MS_GASP_TAG MS_MAKE_TAG('g', 'a', 's', 'p')
197
198 #define GASP_GRIDFIT 0x01
199 #define GASP_DOGRAY 0x02
200
201 #ifdef WORDS_BIGENDIAN
202 #define get_be_word(x) (x)
203 #define NATIVE_BYTE_ORDER MSBFirst
204 #else
205 #define get_be_word(x) RtlUshortByteSwap(x)
206 #define NATIVE_BYTE_ORDER LSBFirst
207 #endif
208
209 static BOOL get_xrender_template(const WineXRenderFormatTemplate *fmt, XRenderPictFormat *templ, unsigned long *mask)
210 {
211 templ->id = 0;
212 templ->type = PictTypeDirect;
213 templ->depth = fmt->depth;
214 templ->direct.alpha = fmt->alpha;
215 templ->direct.alphaMask = fmt->alphaMask;
216 templ->direct.red = fmt->red;
217 templ->direct.redMask = fmt->redMask;
218 templ->direct.green = fmt->green;
219 templ->direct.greenMask = fmt->greenMask;
220 templ->direct.blue = fmt->blue;
221 templ->direct.blueMask = fmt->blueMask;
222 templ->colormap = 0;
223
224 *mask = PictFormatType | PictFormatDepth | PictFormatAlpha | PictFormatAlphaMask | PictFormatRed | PictFormatRedMask | PictFormatGreen | PictFormatGreenMask | PictFormatBlue | PictFormatBlueMask;
225
226 return TRUE;
227 }
228
229 static BOOL is_wxrformat_compatible_with_default_visual(const WineXRenderFormatTemplate *fmt)
230 {
231 if(fmt->depth != screen_depth)
232 return FALSE;
233 if( (fmt->redMask << fmt->red) != visual->red_mask)
234 return FALSE;
235 if( (fmt->greenMask << fmt->green) != visual->green_mask)
236 return FALSE;
237 if( (fmt->blueMask << fmt->blue) != visual->blue_mask)
238 return FALSE;
239
240 /* We never select a default ARGB visual */
241 if(fmt->alphaMask)
242 return FALSE;
243
244 return TRUE;
245 }
246
247 static int load_xrender_formats(void)
248 {
249 unsigned int i;
250 for(i = 0; i < (sizeof(wxr_formats_template) / sizeof(wxr_formats_template[0])); i++)
251 {
252 XRenderPictFormat templ, *pict_format;
253
254 if(is_wxrformat_compatible_with_default_visual(&wxr_formats_template[i]))
255 {
256 wine_tsx11_lock();
257 pict_format = pXRenderFindVisualFormat(gdi_display, visual);
258 if(!pict_format)
259 {
260 /* Xrender doesn't like DirectColor visuals, try to find a TrueColor one instead */
261 if (visual->class == DirectColor)
262 {
263 XVisualInfo info;
264 if (XMatchVisualInfo( gdi_display, DefaultScreen(gdi_display),
265 screen_depth, TrueColor, &info ))
266 {
267 pict_format = pXRenderFindVisualFormat(gdi_display, info.visual);
268 if (pict_format) visual = info.visual;
269 }
270 }
271 }
272 wine_tsx11_unlock();
273
274 if(pict_format)
275 {
276 wxr_formats[WineXRenderFormatsListSize].format = wxr_formats_template[i].wxr_format;
277 wxr_formats[WineXRenderFormatsListSize].pict_format = pict_format;
278 default_format = &wxr_formats[WineXRenderFormatsListSize];
279 WineXRenderFormatsListSize++;
280 TRACE("Loaded pict_format with id=%#lx for wxr_format=%#x\n", pict_format->id, wxr_formats_template[i].wxr_format);
281 }
282 }
283 else
284 {
285 unsigned long mask = 0;
286 get_xrender_template(&wxr_formats_template[i], &templ, &mask);
287
288 wine_tsx11_lock();
289 pict_format = pXRenderFindFormat(gdi_display, mask, &templ, 0);
290 wine_tsx11_unlock();
291
292 if(pict_format)
293 {
294 wxr_formats[WineXRenderFormatsListSize].format = wxr_formats_template[i].wxr_format;
295 wxr_formats[WineXRenderFormatsListSize].pict_format = pict_format;
296 WineXRenderFormatsListSize++;
297 TRACE("Loaded pict_format with id=%#lx for wxr_format=%#x\n", pict_format->id, wxr_formats_template[i].wxr_format);
298 }
299 }
300 }
301 return WineXRenderFormatsListSize;
302 }
303
304 /***********************************************************************
305 * X11DRV_XRender_Init
306 *
307 * Let's see if our XServer has the extension available
308 *
309 */
310 void X11DRV_XRender_Init(void)
311 {
312 int event_base, i;
313
314 if (client_side_with_render &&
315 wine_dlopen(SONAME_LIBX11, RTLD_NOW|RTLD_GLOBAL, NULL, 0) &&
316 wine_dlopen(SONAME_LIBXEXT, RTLD_NOW|RTLD_GLOBAL, NULL, 0) &&
317 (xrender_handle = wine_dlopen(SONAME_LIBXRENDER, RTLD_NOW, NULL, 0)))
318 {
319
320 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(xrender_handle, #f, NULL, 0)) == NULL) goto sym_not_found;
321 LOAD_FUNCPTR(XRenderAddGlyphs)
322 LOAD_FUNCPTR(XRenderComposite)
323 LOAD_FUNCPTR(XRenderCompositeString8)
324 LOAD_FUNCPTR(XRenderCompositeString16)
325 LOAD_FUNCPTR(XRenderCompositeString32)
326 LOAD_FUNCPTR(XRenderCompositeText16)
327 LOAD_FUNCPTR(XRenderCreateGlyphSet)
328 LOAD_FUNCPTR(XRenderCreatePicture)
329 LOAD_FUNCPTR(XRenderFillRectangle)
330 LOAD_FUNCPTR(XRenderFindFormat)
331 LOAD_FUNCPTR(XRenderFindVisualFormat)
332 LOAD_FUNCPTR(XRenderFreeGlyphSet)
333 LOAD_FUNCPTR(XRenderFreePicture)
334 LOAD_FUNCPTR(XRenderSetPictureClipRectangles)
335 LOAD_FUNCPTR(XRenderQueryExtension)
336 #undef LOAD_FUNCPTR
337 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
338 #define LOAD_OPTIONAL_FUNCPTR(f) p##f = wine_dlsym(xrender_handle, #f, NULL, 0);
339 LOAD_OPTIONAL_FUNCPTR(XRenderSetPictureTransform)
340 #undef LOAD_OPTIONAL_FUNCPTR
341 #endif
342
343 wine_tsx11_lock();
344 X11DRV_XRender_Installed = pXRenderQueryExtension(gdi_display, &event_base, &xrender_error_base);
345 wine_tsx11_unlock();
346 if(X11DRV_XRender_Installed) {
347 TRACE("Xrender is up and running error_base = %d\n", xrender_error_base);
348 if(!load_xrender_formats()) /* This fails in buggy versions of libXrender.so */
349 {
350 wine_tsx11_unlock();
351 WINE_MESSAGE(
352 "Wine has detected that you probably have a buggy version\n"
353 "of libXrender.so . Because of this client side font rendering\n"
354 "will be disabled. Please upgrade this library.\n");
355 X11DRV_XRender_Installed = FALSE;
356 return;
357 }
358
359 if (!visual->red_mask || !visual->green_mask || !visual->blue_mask) {
360 WARN("one or more of the colour masks are 0, disabling XRENDER. Try running in 16-bit mode or higher.\n");
361 X11DRV_XRender_Installed = FALSE;
362 }
363 }
364 }
365
366 sym_not_found:
367 if(X11DRV_XRender_Installed || client_side_with_core)
368 {
369 glyphsetCache = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
370 sizeof(*glyphsetCache) * INIT_CACHE_SIZE);
371
372 glyphsetCacheSize = INIT_CACHE_SIZE;
373 lastfree = 0;
374 for(i = 0; i < INIT_CACHE_SIZE; i++) {
375 glyphsetCache[i].next = i + 1;
376 glyphsetCache[i].count = -1;
377 }
378 glyphsetCache[i-1].next = -1;
379 using_client_side_fonts = 1;
380
381 if(!X11DRV_XRender_Installed) {
382 TRACE("Xrender is not available on your XServer, client side rendering with the core protocol instead.\n");
383 if(screen_depth <= 8 || !client_side_antialias_with_core)
384 antialias = 0;
385 } else {
386 if(screen_depth <= 8 || !client_side_antialias_with_render)
387 antialias = 0;
388 }
389 }
390 else TRACE("Using X11 core fonts\n");
391 }
392
393 /* Helper function to convert from a color packed in a 32-bit integer to a XRenderColor */
394 static void get_xrender_color(WineXRenderFormat *wxr_format, int src_color, XRenderColor *dst_color)
395 {
396 XRenderPictFormat *pf = wxr_format->pict_format;
397
398 if(pf->direct.redMask)
399 dst_color->red = ((src_color >> pf->direct.red) & pf->direct.redMask) * 65535/pf->direct.redMask;
400 else
401 dst_color->red = 0;
402
403 if(pf->direct.greenMask)
404 dst_color->green = ((src_color >> pf->direct.green) & pf->direct.greenMask) * 65535/pf->direct.greenMask;
405 else
406 dst_color->green = 0;
407
408 if(pf->direct.blueMask)
409 dst_color->blue = ((src_color >> pf->direct.blue) & pf->direct.blueMask) * 65535/pf->direct.blueMask;
410 else
411 dst_color->blue = 0;
412
413 dst_color->alpha = 0xffff;
414 }
415
416 static WineXRenderFormat *get_xrender_format(WXRFormat format)
417 {
418 int i;
419 for(i=0; i<WineXRenderFormatsListSize; i++)
420 {
421 if(wxr_formats[i].format == format)
422 {
423 TRACE("Returning wxr_format=%#x\n", format);
424 return &wxr_formats[i];
425 }
426 }
427 return NULL;
428 }
429
430 static WineXRenderFormat *get_xrender_format_from_color_shifts(int depth, ColorShifts *shifts)
431 {
432 int redMask, greenMask, blueMask;
433 unsigned int i;
434
435 if(depth == 1)
436 return get_xrender_format(WXR_FORMAT_MONO);
437
438 /* physDevs of a depth <=8, don't have color_shifts set and XRender can't handle those except for 1-bit */
439 if(!shifts)
440 return default_format;
441
442 redMask = shifts->physicalRed.max << shifts->physicalRed.shift;
443 greenMask = shifts->physicalGreen.max << shifts->physicalGreen.shift;
444 blueMask = shifts->physicalBlue.max << shifts->physicalBlue.shift;
445
446 /* Try to locate a format which matches the specification of the dibsection. */
447 for(i = 0; i < (sizeof(wxr_formats_template) / sizeof(wxr_formats_template[0])); i++)
448 {
449 if( depth == wxr_formats_template[i].depth &&
450 redMask == (wxr_formats_template[i].redMask << wxr_formats_template[i].red) &&
451 greenMask == (wxr_formats_template[i].greenMask << wxr_formats_template[i].green) &&
452 blueMask == (wxr_formats_template[i].blueMask << wxr_formats_template[i].blue) )
453
454 {
455 /* When we reach this stage the format was found in our template table but this doesn't mean that
456 * the Xserver also supports this format (e.g. its depth might be too low). The call below verifies that.
457 */
458 return get_xrender_format(wxr_formats_template[i].wxr_format);
459 }
460 }
461
462 /* This should not happen because when we reach 'shifts' must have been set and we only allows shifts which are backed by X */
463 ERR("No XRender format found!\n");
464 return NULL;
465 }
466
467 static BOOL fontcmp(LFANDSIZE *p1, LFANDSIZE *p2)
468 {
469 if(p1->hash != p2->hash) return TRUE;
470 if(memcmp(&p1->devsize, &p2->devsize, sizeof(p1->devsize))) return TRUE;
471 if(memcmp(&p1->xform, &p2->xform, sizeof(p1->xform))) return TRUE;
472 if(memcmp(&p1->lf, &p2->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE;
473 return strcmpiW(p1->lf.lfFaceName, p2->lf.lfFaceName);
474 }
475
476 #if 0
477 static void walk_cache(void)
478 {
479 int i;
480
481 EnterCriticalSection(&xrender_cs);
482 for(i=mru; i >= 0; i = glyphsetCache[i].next)
483 TRACE("item %d\n", i);
484 LeaveCriticalSection(&xrender_cs);
485 }
486 #endif
487
488 static int LookupEntry(LFANDSIZE *plfsz)
489 {
490 int i, prev_i = -1;
491
492 for(i = mru; i >= 0; i = glyphsetCache[i].next) {
493 TRACE("%d\n", i);
494 if(glyphsetCache[i].count == -1) { /* reached free list so stop */
495 i = -1;
496 break;
497 }
498
499 if(!fontcmp(&glyphsetCache[i].lfsz, plfsz)) {
500 glyphsetCache[i].count++;
501 if(prev_i >= 0) {
502 glyphsetCache[prev_i].next = glyphsetCache[i].next;
503 glyphsetCache[i].next = mru;
504 mru = i;
505 }
506 TRACE("found font in cache %d\n", i);
507 return i;
508 }
509 prev_i = i;
510 }
511 TRACE("font not in cache\n");
512 return -1;
513 }
514
515 static void FreeEntry(int entry)
516 {
517 int i, format;
518
519 for(format = 0; format < AA_MAXVALUE; format++) {
520 gsCacheEntryFormat * formatEntry;
521
522 if( !glyphsetCache[entry].format[format] )
523 continue;
524
525 formatEntry = glyphsetCache[entry].format[format];
526
527 if(formatEntry->glyphset) {
528 wine_tsx11_lock();
529 pXRenderFreeGlyphSet(gdi_display, formatEntry->glyphset);
530 wine_tsx11_unlock();
531 formatEntry->glyphset = 0;
532 }
533 if(formatEntry->nrealized) {
534 HeapFree(GetProcessHeap(), 0, formatEntry->realized);
535 formatEntry->realized = NULL;
536 if(formatEntry->bitmaps) {
537 for(i = 0; i < formatEntry->nrealized; i++)
538 HeapFree(GetProcessHeap(), 0, formatEntry->bitmaps[i]);
539 HeapFree(GetProcessHeap(), 0, formatEntry->bitmaps);
540 formatEntry->bitmaps = NULL;
541 }
542 HeapFree(GetProcessHeap(), 0, formatEntry->gis);
543 formatEntry->gis = NULL;
544 formatEntry->nrealized = 0;
545 }
546
547 HeapFree(GetProcessHeap(), 0, formatEntry);
548 glyphsetCache[entry].format[format] = NULL;
549 }
550 }
551
552 static int AllocEntry(void)
553 {
554 int best = -1, prev_best = -1, i, prev_i = -1;
555
556 if(lastfree >= 0) {
557 assert(glyphsetCache[lastfree].count == -1);
558 glyphsetCache[lastfree].count = 1;
559 best = lastfree;
560 lastfree = glyphsetCache[lastfree].next;
561 assert(best != mru);
562 glyphsetCache[best].next = mru;
563 mru = best;
564
565 TRACE("empty space at %d, next lastfree = %d\n", mru, lastfree);
566 return mru;
567 }
568
569 for(i = mru; i >= 0; i = glyphsetCache[i].next) {
570 if(glyphsetCache[i].count == 0) {
571 best = i;
572 prev_best = prev_i;
573 }
574 prev_i = i;
575 }
576
577 if(best >= 0) {
578 TRACE("freeing unused glyphset at cache %d\n", best);
579 FreeEntry(best);
580 glyphsetCache[best].count = 1;
581 if(prev_best >= 0) {
582 glyphsetCache[prev_best].next = glyphsetCache[best].next;
583 glyphsetCache[best].next = mru;
584 mru = best;
585 } else {
586 assert(mru == best);
587 }
588 return mru;
589 }
590
591 TRACE("Growing cache\n");
592
593 if (glyphsetCache)
594 glyphsetCache = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
595 glyphsetCache,
596 (glyphsetCacheSize + INIT_CACHE_SIZE)
597 * sizeof(*glyphsetCache));
598 else
599 glyphsetCache = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
600 (glyphsetCacheSize + INIT_CACHE_SIZE)
601 * sizeof(*glyphsetCache));
602
603 for(best = i = glyphsetCacheSize; i < glyphsetCacheSize + INIT_CACHE_SIZE;
604 i++) {
605 glyphsetCache[i].next = i + 1;
606 glyphsetCache[i].count = -1;
607 }
608 glyphsetCache[i-1].next = -1;
609 glyphsetCacheSize += INIT_CACHE_SIZE;
610
611 lastfree = glyphsetCache[best].next;
612 glyphsetCache[best].count = 1;
613 glyphsetCache[best].next = mru;
614 mru = best;
615 TRACE("new free cache slot at %d\n", mru);
616 return mru;
617 }
618
619 static BOOL get_gasp_flags(X11DRV_PDEVICE *physDev, WORD *flags)
620 {
621 DWORD size;
622 WORD *gasp, *buffer;
623 WORD num_recs;
624 DWORD ppem;
625 TEXTMETRICW tm;
626
627 *flags = 0;
628
629 size = GetFontData(physDev->hdc, MS_GASP_TAG, 0, NULL, 0);
630 if(size == GDI_ERROR)
631 return FALSE;
632
633 gasp = buffer = HeapAlloc(GetProcessHeap(), 0, size);
634 GetFontData(physDev->hdc, MS_GASP_TAG, 0, gasp, size);
635
636 GetTextMetricsW(physDev->hdc, &tm);
637 ppem = abs(X11DRV_YWStoDS(physDev, tm.tmAscent + tm.tmDescent - tm.tmInternalLeading));
638
639 gasp++;
640 num_recs = get_be_word(*gasp);
641 gasp++;
642 while(num_recs--)
643 {
644 *flags = get_be_word(*(gasp + 1));
645 if(ppem <= get_be_word(*gasp))
646 break;
647 gasp += 2;
648 }
649 TRACE("got flags %04x for ppem %d\n", *flags, ppem);
650
651 HeapFree(GetProcessHeap(), 0, buffer);
652 return TRUE;
653 }
654
655 static AA_Type get_antialias_type( X11DRV_PDEVICE *physDev, BOOL subpixel, BOOL hinter)
656 {
657 AA_Type ret;
658 WORD flags;
659 UINT font_smoothing_type, font_smoothing_orientation;
660
661 if (X11DRV_XRender_Installed && subpixel &&
662 SystemParametersInfoW( SPI_GETFONTSMOOTHINGTYPE, 0, &font_smoothing_type, 0) &&
663 font_smoothing_type == FE_FONTSMOOTHINGCLEARTYPE)
664 {
665 if ( SystemParametersInfoW( SPI_GETFONTSMOOTHINGORIENTATION, 0,
666 &font_smoothing_orientation, 0) &&
667 font_smoothing_orientation == FE_FONTSMOOTHINGORIENTATIONBGR)
668 {
669 ret = AA_BGR;
670 }
671 else
672 ret = AA_RGB;
673 /*FIXME
674 If the monitor is in portrait mode, ClearType is disabled in the MS Windows (MSDN).
675 But, Wine's subpixel rendering can support the portrait mode.
676 */
677 }
678 else if (!hinter || !get_gasp_flags(physDev, &flags) || flags & GASP_DOGRAY)
679 ret = AA_Grey;
680 else
681 ret = AA_None;
682
683 return ret;
684 }
685
686 static int GetCacheEntry(X11DRV_PDEVICE *physDev, LFANDSIZE *plfsz)
687 {
688 int ret;
689 int format;
690 gsCacheEntry *entry;
691 static int hinter = -1;
692 static int subpixel = -1;
693 BOOL font_smoothing;
694
695 if((ret = LookupEntry(plfsz)) != -1) return ret;
696
697 ret = AllocEntry();
698 entry = glyphsetCache + ret;
699 entry->lfsz = *plfsz;
700 for( format = 0; format < AA_MAXVALUE; format++ ) {
701 assert( !entry->format[format] );
702 }
703
704 if(antialias && plfsz->lf.lfQuality != NONANTIALIASED_QUALITY)
705 {
706 if(hinter == -1 || subpixel == -1)
707 {
708 RASTERIZER_STATUS status;
709 GetRasterizerCaps(&status, sizeof(status));
710 hinter = status.wFlags & WINE_TT_HINTER_ENABLED;
711 subpixel = status.wFlags & WINE_TT_SUBPIXEL_RENDERING_ENABLED;
712 }
713
714 switch (plfsz->lf.lfQuality)
715 {
716 case ANTIALIASED_QUALITY:
717 entry->aa_default = get_antialias_type( physDev, FALSE, hinter );
718 break;
719 case CLEARTYPE_QUALITY:
720 case CLEARTYPE_NATURAL_QUALITY:
721 entry->aa_default = get_antialias_type( physDev, subpixel, hinter );
722 break;
723 case DEFAULT_QUALITY:
724 case DRAFT_QUALITY:
725 case PROOF_QUALITY:
726 default:
727 if ( SystemParametersInfoW( SPI_GETFONTSMOOTHING, 0, &font_smoothing, 0) &&
728 font_smoothing)
729 {
730 entry->aa_default = get_antialias_type( physDev, subpixel, hinter );
731 }
732 else
733 entry->aa_default = AA_None;
734 break;
735 }
736 }
737 else
738 entry->aa_default = AA_None;
739
740 return ret;
741 }
742
743 static void dec_ref_cache(int index)
744 {
745 assert(index >= 0);
746 TRACE("dec'ing entry %d to %d\n", index, glyphsetCache[index].count - 1);
747 assert(glyphsetCache[index].count > 0);
748 glyphsetCache[index].count--;
749 }
750
751 static void lfsz_calc_hash(LFANDSIZE *plfsz)
752 {
753 DWORD hash = 0, *ptr, two_chars;
754 WORD *pwc;
755 int i;
756
757 hash ^= plfsz->devsize.cx;
758 hash ^= plfsz->devsize.cy;
759 for(i = 0, ptr = (DWORD*)&plfsz->xform; i < sizeof(XFORM)/sizeof(DWORD); i++, ptr++)
760 hash ^= *ptr;
761 for(i = 0, ptr = (DWORD*)&plfsz->lf; i < 7; i++, ptr++)
762 hash ^= *ptr;
763 for(i = 0, ptr = (DWORD*)plfsz->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) {
764 two_chars = *ptr;
765 pwc = (WCHAR *)&two_chars;
766 if(!*pwc) break;
767 *pwc = toupperW(*pwc);
768 pwc++;
769 *pwc = toupperW(*pwc);
770 hash ^= two_chars;
771 if(!*pwc) break;
772 }
773 plfsz->hash = hash;
774 return;
775 }
776
777 /***********************************************************************
778 * X11DRV_XRender_Finalize
779 */
780 void X11DRV_XRender_Finalize(void)
781 {
782 int i;
783
784 EnterCriticalSection(&xrender_cs);
785 for(i = mru; i >= 0; i = glyphsetCache[i].next)
786 FreeEntry(i);
787 LeaveCriticalSection(&xrender_cs);
788 }
789
790
791 /***********************************************************************
792 * X11DRV_XRender_SelectFont
793 */
794 BOOL X11DRV_XRender_SelectFont(X11DRV_PDEVICE *physDev, HFONT hfont)
795 {
796 LFANDSIZE lfsz;
797
798 GetObjectW(hfont, sizeof(lfsz.lf), &lfsz.lf);
799 TRACE("h=%d w=%d weight=%d it=%d charset=%d name=%s\n",
800 lfsz.lf.lfHeight, lfsz.lf.lfWidth, lfsz.lf.lfWeight,
801 lfsz.lf.lfItalic, lfsz.lf.lfCharSet, debugstr_w(lfsz.lf.lfFaceName));
802 lfsz.lf.lfWidth = abs( lfsz.lf.lfWidth );
803 lfsz.devsize.cx = X11DRV_XWStoDS( physDev, lfsz.lf.lfWidth );
804 lfsz.devsize.cy = X11DRV_YWStoDS( physDev, lfsz.lf.lfHeight );
805 GetWorldTransform( physDev->hdc, &lfsz.xform );
806 lfsz_calc_hash(&lfsz);
807
808 EnterCriticalSection(&xrender_cs);
809 if(!physDev->xrender) {
810 physDev->xrender = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
811 sizeof(*physDev->xrender));
812 physDev->xrender->cache_index = -1;
813 }
814 else if(physDev->xrender->cache_index != -1)
815 dec_ref_cache(physDev->xrender->cache_index);
816 physDev->xrender->cache_index = GetCacheEntry(physDev, &lfsz);
817 LeaveCriticalSection(&xrender_cs);
818 return 0;
819 }
820
821 /***********************************************************************
822 * X11DRV_XRender_DeleteDC
823 */
824 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE *physDev)
825 {
826 X11DRV_XRender_UpdateDrawable(physDev);
827
828 EnterCriticalSection(&xrender_cs);
829 if(physDev->xrender->cache_index != -1)
830 dec_ref_cache(physDev->xrender->cache_index);
831 LeaveCriticalSection(&xrender_cs);
832
833 HeapFree(GetProcessHeap(), 0, physDev->xrender);
834 physDev->xrender = NULL;
835 return;
836 }
837
838 /***********************************************************************
839 * X11DRV_XRender_UpdateDrawable
840 *
841 * Deletes the pict and tile when the drawable changes.
842 */
843 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE *physDev)
844 {
845 wine_tsx11_lock();
846
847 if(physDev->xrender->pict)
848 {
849 TRACE("freeing pict = %lx dc = %p\n", physDev->xrender->pict, physDev->hdc);
850 XFlush(gdi_display);
851 pXRenderFreePicture(gdi_display, physDev->xrender->pict);
852 physDev->xrender->pict = 0;
853 }
854 wine_tsx11_unlock();
855
856 return;
857 }
858
859 /************************************************************************
860 * UploadGlyph
861 *
862 * Helper to ExtTextOut. Must be called inside xrender_cs
863 */
864 static BOOL UploadGlyph(X11DRV_PDEVICE *physDev, int glyph, AA_Type format)
865 {
866 unsigned int buflen;
867 char *buf;
868 Glyph gid;
869 GLYPHMETRICS gm;
870 XGlyphInfo gi;
871 gsCacheEntry *entry = glyphsetCache + physDev->xrender->cache_index;
872 gsCacheEntryFormat *formatEntry;
873 UINT ggo_format = GGO_GLYPH_INDEX;
874 WXRFormat wxr_format;
875 static const char zero[4];
876 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
877
878 switch(format) {
879 case AA_Grey:
880 ggo_format |= WINE_GGO_GRAY16_BITMAP;
881 break;
882 case AA_RGB:
883 ggo_format |= WINE_GGO_HRGB_BITMAP;
884 break;
885 case AA_BGR:
886 ggo_format |= WINE_GGO_HBGR_BITMAP;
887 break;
888 case AA_VRGB:
889 ggo_format |= WINE_GGO_VRGB_BITMAP;
890 break;
891 case AA_VBGR:
892 ggo_format |= WINE_GGO_VBGR_BITMAP;
893 break;
894
895 default:
896 ERR("aa = %d - not implemented\n", format);
897 case AA_None:
898 ggo_format |= GGO_BITMAP;
899 break;
900 }
901
902 buflen = GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, 0, NULL, &identity);
903 if(buflen == GDI_ERROR) {
904 if(format != AA_None) {
905 format = AA_None;
906 entry->aa_default = AA_None;
907 ggo_format = GGO_GLYPH_INDEX | GGO_BITMAP;
908 buflen = GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, 0, NULL, &identity);
909 }
910 if(buflen == GDI_ERROR) {
911 WARN("GetGlyphOutlineW failed\n");
912 return FALSE;
913 }
914 TRACE("Turning off antialiasing for this monochrome font\n");
915 }
916
917 /* If there is nothing for the current type, we create the entry. */
918 if( !entry->format[format] ) {
919 entry->format[format] = HeapAlloc(GetProcessHeap(),
920 HEAP_ZERO_MEMORY,
921 sizeof(gsCacheEntryFormat));
922 }
923 formatEntry = entry->format[format];
924
925 if(formatEntry->nrealized <= glyph) {
926 formatEntry->nrealized = (glyph / 128 + 1) * 128;
927
928 if (formatEntry->realized)
929 formatEntry->realized = HeapReAlloc(GetProcessHeap(),
930 HEAP_ZERO_MEMORY,
931 formatEntry->realized,
932 formatEntry->nrealized * sizeof(BOOL));
933 else
934 formatEntry->realized = HeapAlloc(GetProcessHeap(),
935 HEAP_ZERO_MEMORY,
936 formatEntry->nrealized * sizeof(BOOL));
937
938 if(!X11DRV_XRender_Installed) {
939 if (formatEntry->bitmaps)
940 formatEntry->bitmaps = HeapReAlloc(GetProcessHeap(),
941 HEAP_ZERO_MEMORY,
942 formatEntry->bitmaps,
943 formatEntry->nrealized * sizeof(formatEntry->bitmaps[0]));
944 else
945 formatEntry->bitmaps = HeapAlloc(GetProcessHeap(),
946 HEAP_ZERO_MEMORY,
947 formatEntry->nrealized * sizeof(formatEntry->bitmaps[0]));
948 }
949 if (formatEntry->gis)
950 formatEntry->gis = HeapReAlloc(GetProcessHeap(),
951 HEAP_ZERO_MEMORY,
952 formatEntry->gis,
953 formatEntry->nrealized * sizeof(formatEntry->gis[0]));
954 else
955 formatEntry->gis = HeapAlloc(GetProcessHeap(),
956 HEAP_ZERO_MEMORY,
957 formatEntry->nrealized * sizeof(formatEntry->gis[0]));
958 }
959
960
961 if(formatEntry->glyphset == 0 && X11DRV_XRender_Installed) {
962 switch(format) {
963 case AA_Grey:
964 wxr_format = WXR_FORMAT_GRAY;
965 break;
966
967 case AA_RGB:
968 case AA_BGR:
969 case AA_VRGB:
970 case AA_VBGR:
971 wxr_format = WXR_FORMAT_A8R8G8B8;
972 break;
973
974 default:
975 ERR("aa = %d - not implemented\n", format);
976 case AA_None:
977 wxr_format = WXR_FORMAT_MONO;
978 break;
979 }
980
981 wine_tsx11_lock();
982 formatEntry->font_format = get_xrender_format(wxr_format);
983 formatEntry->glyphset = pXRenderCreateGlyphSet(gdi_display, formatEntry->font_format->pict_format);
984 wine_tsx11_unlock();
985 }
986
987
988 buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buflen);
989 GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, buflen, buf, &identity);
990 formatEntry->realized[glyph] = TRUE;
991
992 TRACE("buflen = %d. Got metrics: %dx%d adv=%d,%d origin=%d,%d\n",
993 buflen,
994 gm.gmBlackBoxX, gm.gmBlackBoxY, gm.gmCellIncX, gm.gmCellIncY,
995 gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
996
997 gi.width = gm.gmBlackBoxX;
998 gi.height = gm.gmBlackBoxY;
999 gi.x = -gm.gmptGlyphOrigin.x;
1000 gi.y = gm.gmptGlyphOrigin.y;
1001 gi.xOff = gm.gmCellIncX;
1002 gi.yOff = gm.gmCellIncY;
1003
1004 if(TRACE_ON(xrender)) {
1005 int pitch, i, j;
1006 char output[300];
1007 unsigned char *line;
1008
1009 if(format == AA_None) {
1010 pitch = ((gi.width + 31) / 32) * 4;
1011 for(i = 0; i < gi.height; i++) {
1012 line = (unsigned char*) buf + i * pitch;
1013 output[0] = '\0';
1014 for(j = 0; j < pitch * 8; j++) {
1015 strcat(output, (line[j / 8] & (1 << (7 - (j % 8)))) ? "#" : " ");
1016 }
1017 TRACE("%s\n", output);
1018 }
1019 } else {
1020 static const char blks[] = " .:;!o*#";
1021 char str[2];
1022
1023 str[1] = '\0';
1024 pitch = ((gi.width + 3) / 4) * 4;
1025 for(i = 0; i < gi.height; i++) {
1026 line = (unsigned char*) buf + i * pitch;
1027 output[0] = '\0';
1028 for(j = 0; j < pitch; j++) {
1029 str[0] = blks[line[j] >> 5];
1030 strcat(output, str);
1031 }
1032 TRACE("%s\n", output);
1033 }
1034 }
1035 }
1036
1037
1038 if(formatEntry->glyphset) {
1039 if(format == AA_None && BitmapBitOrder(gdi_display) != MSBFirst) {
1040 unsigned char *byte = (unsigned char*) buf, c;
1041 int i = buflen;
1042
1043 while(i--) {
1044 c = *byte;
1045
1046 /* magic to flip bit order */
1047 c = ((c << 1) & 0xaa) | ((c >> 1) & 0x55);
1048 c = ((c << 2) & 0xcc) | ((c >> 2) & 0x33);
1049 c = ((c << 4) & 0xf0) | ((c >> 4) & 0x0f);
1050
1051 *byte++ = c;
1052 }
1053 }
1054 else if ( format != AA_Grey &&
1055 ImageByteOrder (gdi_display) != NATIVE_BYTE_ORDER)
1056 {
1057 unsigned int i, *data = (unsigned int *)buf;
1058 for (i = buflen / sizeof(int); i; i--, data++) *data = RtlUlongByteSwap(*data);
1059 }
1060 gid = glyph;
1061
1062 /*
1063 XRenderCompositeText seems to ignore 0x0 glyphs when
1064 AA_None, which means we lose the advance width of glyphs
1065 like the space. We'll pretend that such glyphs are 1x1
1066 bitmaps.
1067 */
1068
1069 if(buflen == 0)
1070 gi.width = gi.height = 1;
1071
1072 wine_tsx11_lock();
1073 pXRenderAddGlyphs(gdi_display, formatEntry->glyphset, &gid, &gi, 1,
1074 buflen ? buf : zero, buflen ? buflen : sizeof(zero));
1075 wine_tsx11_unlock();
1076 HeapFree(GetProcessHeap(), 0, buf);
1077 } else {
1078 formatEntry->bitmaps[glyph] = buf;
1079 }
1080
1081 formatEntry->gis[glyph] = gi;
1082
1083 return TRUE;
1084 }
1085
1086 static void SharpGlyphMono(X11DRV_PDEVICE *physDev, INT x, INT y,
1087 void *bitmap, XGlyphInfo *gi)
1088 {
1089 unsigned char *srcLine = bitmap, *src;
1090 unsigned char bits, bitsMask;
1091 int width = gi->width;
1092 int stride = ((width + 31) & ~31) >> 3;
1093 int height = gi->height;
1094 int w;
1095 int xspan, lenspan;
1096
1097 TRACE("%d, %d\n", x, y);
1098 x -= gi->x;
1099 y -= gi->y;
1100 while (height--)
1101 {
1102 src = srcLine;
1103 srcLine += stride;
1104 w = width;
1105
1106 bitsMask = 0x80; /* FreeType is always MSB first */
1107 bits = *src++;
1108
1109 xspan = x;
1110 while (w)
1111 {
1112 if (bits & bitsMask)
1113 {
1114 lenspan = 0;
1115 do
1116 {
1117 lenspan++;
1118 if (lenspan == w)
1119 break;
1120 bitsMask = bitsMask >> 1;
1121 if (!bitsMask)
1122 {
1123 bits = *src++;
1124 bitsMask = 0x80;
1125 }
1126 } while (bits & bitsMask);
1127 XFillRectangle (gdi_display, physDev->drawable,
1128 physDev->gc, xspan, y, lenspan, 1);
1129 xspan += lenspan;
1130 w -= lenspan;
1131 }
1132 else
1133 {
1134 do
1135 {
1136 w--;
1137 xspan++;
1138 if (!w)
1139 break;
1140 bitsMask = bitsMask >> 1;
1141 if (!bitsMask)
1142 {
1143 bits = *src++;
1144 bitsMask = 0x80;
1145 }
1146 } while (!(bits & bitsMask));
1147 }
1148 }
1149 y++;
1150 }
1151 }
1152
1153 static void SharpGlyphGray(X11DRV_PDEVICE *physDev, INT x, INT y,
1154 void *bitmap, XGlyphInfo *gi)
1155 {
1156 unsigned char *srcLine = bitmap, *src, bits;
1157 int width = gi->width;
1158 int stride = ((width + 3) & ~3);
1159 int height = gi->height;
1160 int w;
1161 int xspan, lenspan;
1162
1163 x -= gi->x;
1164 y -= gi->y;
1165 while (height--)
1166 {
1167 src = srcLine;
1168 srcLine += stride;
1169 w = width;
1170
1171 bits = *src++;
1172 xspan = x;
1173 while (w)
1174 {
1175 if (bits >= 0x80)
1176 {
1177 lenspan = 0;
1178 do
1179 {
1180 lenspan++;
1181 if (lenspan == w)
1182 break;
1183 bits = *src++;
1184 } while (bits >= 0x80);
1185 XFillRectangle (gdi_display, physDev->drawable,
1186 physDev->gc, xspan, y, lenspan, 1);
1187 xspan += lenspan;
1188 w -= lenspan;
1189 }
1190 else
1191 {
1192 do
1193 {
1194 w--;
1195 xspan++;
1196 if (!w)
1197 break;
1198 bits = *src++;
1199 } while (bits < 0x80);
1200 }
1201 }
1202 y++;
1203 }
1204 }
1205
1206
1207 static void ExamineBitfield (DWORD mask, int *shift, int *len)
1208 {
1209 int s, l;
1210
1211 s = 0;
1212 while ((mask & 1) == 0)
1213 {
1214 mask >>= 1;
1215 s++;
1216 }
1217 l = 0;
1218 while ((mask & 1) == 1)
1219 {
1220 mask >>= 1;
1221 l++;
1222 }
1223 *shift = s;
1224 *len = l;
1225 }
1226
1227 static DWORD GetField (DWORD pixel, int shift, int len)
1228 {
1229 pixel = pixel & (((1 << (len)) - 1) << shift);
1230 pixel = pixel << (32 - (shift + len)) >> 24;
1231 while (len < 8)
1232 {
1233 pixel |= (pixel >> len);
1234 len <<= 1;
1235 }
1236 return pixel;
1237 }
1238
1239
1240 static DWORD PutField (DWORD pixel, int shift, int len)
1241 {
1242 shift = shift - (8 - len);
1243 if (len <= 8)
1244 pixel &= (((1 << len) - 1) << (8 - len));
1245 if (shift < 0)
1246 pixel >>= -shift;
1247 else
1248 pixel <<= shift;
1249 return pixel;
1250 }
1251
1252 static void SmoothGlyphGray(XImage *image, int x, int y, void *bitmap, XGlyphInfo *gi,
1253 int color)
1254 {
1255 int r_shift, r_len;
1256 int g_shift, g_len;
1257 int b_shift, b_len;
1258 BYTE *maskLine, *mask, m;
1259 int maskStride;
1260 DWORD pixel;
1261 int width, height;
1262 int w, tx;
1263 BYTE src_r, src_g, src_b;
1264
1265 x -= gi->x;
1266 y -= gi->y;
1267 width = gi->width;
1268 height = gi->height;
1269
1270 maskLine = bitmap;
1271 maskStride = (width + 3) & ~3;
1272
1273 ExamineBitfield (image->red_mask, &r_shift, &r_len);
1274 ExamineBitfield (image->green_mask, &g_shift, &g_len);
1275 ExamineBitfield (image->blue_mask, &b_shift, &b_len);
1276
1277 src_r = GetField(color, r_shift, r_len);
1278 src_g = GetField(color, g_shift, g_len);
1279 src_b = GetField(color, b_shift, b_len);
1280
1281 for(; height--; y++)
1282 {
1283 mask = maskLine;
1284 maskLine += maskStride;
1285 w = width;
1286 tx = x;
1287
1288 if(y < 0) continue;
1289 if(y >= image->height) break;
1290
1291 for(; w--; tx++)
1292 {
1293 if(tx >= image->width) break;
1294
1295 m = *mask++;
1296 if(tx < 0) continue;
1297
1298 if (m == 0xff)
1299 XPutPixel (image, tx, y, color);
1300 else if (m)
1301 {
1302 BYTE r, g, b;
1303
1304 pixel = XGetPixel (image, tx, y);
1305
1306 r = GetField(pixel, r_shift, r_len);
1307 r = ((BYTE)~m * (WORD)r + (BYTE)m * (WORD)src_r) >> 8;
1308 g = GetField(pixel, g_shift, g_len);
1309 g = ((BYTE)~m * (WORD)g + (BYTE)m * (WORD)src_g) >> 8;
1310 b = GetField(pixel, b_shift, b_len);
1311 b = ((BYTE)~m * (WORD)b + (BYTE)m * (WORD)src_b) >> 8;
1312
1313 pixel = (PutField (r, r_shift, r_len) |
1314 PutField (g, g_shift, g_len) |
1315 PutField (b, b_shift, b_len));
1316 XPutPixel (image, tx, y, pixel);
1317 }
1318 }
1319 }
1320 }
1321
1322 /*************************************************************
1323 * get_tile_pict
1324 *
1325 * Returns an appropriate Picture for tiling the text colour.
1326 * Call and use result within the xrender_cs
1327 */
1328 static Picture get_tile_pict(WineXRenderFormat *wxr_format, int text_pixel)
1329 {
1330 static struct
1331 {
1332 Pixmap xpm;
1333 Picture pict;
1334 int current_color;
1335 } tiles[MAX_FORMATS], *tile;
1336 XRenderColor col;
1337
1338 tile = &tiles[wxr_format->format];
1339
1340 if(!tile->xpm)
1341 {
1342 XRenderPictureAttributes pa;
1343
1344 wine_tsx11_lock();
1345 tile->xpm = XCreatePixmap(gdi_display, root_window, 1, 1, wxr_format->pict_format->depth);
1346
1347 pa.repeat = RepeatNormal;
1348 tile->pict = pXRenderCreatePicture(gdi_display, tile->xpm, wxr_format->pict_format, CPRepeat, &pa);
1349 wine_tsx11_unlock();
1350
1351 /* init current_color to something different from text_pixel */
1352 tile->current_color = ~text_pixel;
1353
1354 if(wxr_format->format == WXR_FORMAT_MONO)
1355 {
1356 /* for a 1bpp bitmap we always need a 1 in the tile */
1357 col.red = col.green = col.blue = 0;
1358 col.alpha = 0xffff;
1359 wine_tsx11_lock();
1360 pXRenderFillRectangle(gdi_display, PictOpSrc, tile->pict, &col, 0, 0, 1, 1);
1361 wine_tsx11_unlock();
1362 }
1363 }
1364
1365 if(text_pixel != tile->current_color && wxr_format->format != WXR_FORMAT_MONO)
1366 {
1367 get_xrender_color(wxr_format, text_pixel, &col);
1368 wine_tsx11_lock();
1369 pXRenderFillRectangle(gdi_display, PictOpSrc, tile->pict, &col, 0, 0, 1, 1);
1370 wine_tsx11_unlock();
1371 tile->current_color = text_pixel;
1372 }
1373 return tile->pict;
1374 }
1375
1376 static int XRenderErrorHandler(Display *dpy, XErrorEvent *event, void *arg)
1377 {
1378 return 1;
1379 }
1380
1381 /***********************************************************************
1382 * X11DRV_XRender_ExtTextOut
1383 */
1384 BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags,
1385 const RECT *lprect, LPCWSTR wstr, UINT count,
1386 const INT *lpDx )
1387 {
1388 RGNDATA *data;
1389 XGCValues xgcval;
1390 gsCacheEntry *entry;
1391 gsCacheEntryFormat *formatEntry;
1392 BOOL retv = FALSE;
1393 HDC hdc = physDev->hdc;
1394 int textPixel, backgroundPixel;
1395 HRGN saved_region = 0;
1396 BOOL disable_antialias = FALSE;
1397 AA_Type aa_type = AA_None;
1398 DIBSECTION bmp;
1399 unsigned int idx;
1400 double cosEsc, sinEsc;
1401 LOGFONTW lf;
1402 WineXRenderFormat *dst_format = get_xrender_format_from_color_shifts(physDev->depth, physDev->color_shifts);
1403 Picture tile_pict = 0;
1404
1405 /* Do we need to disable antialiasing because of palette mode? */
1406 if( !physDev->bitmap || GetObjectW( physDev->bitmap->hbitmap, sizeof(bmp), &bmp ) != sizeof(bmp) ) {
1407 TRACE("bitmap is not a DIB\n");
1408 }
1409 else if (bmp.dsBmih.biBitCount <= 8) {
1410 TRACE("Disabling antialiasing\n");
1411 disable_antialias = TRUE;
1412 }
1413
1414 xgcval.function = GXcopy;
1415 xgcval.background = physDev->backgroundPixel;
1416 xgcval.fill_style = FillSolid;
1417 wine_tsx11_lock();
1418 XChangeGC( gdi_display, physDev->gc, GCFunction | GCBackground | GCFillStyle, &xgcval );
1419 wine_tsx11_unlock();
1420
1421 X11DRV_LockDIBSection( physDev, DIB_Status_GdiMod );
1422
1423 if(physDev->depth == 1) {
1424 if((physDev->textPixel & 0xffffff) == 0) {
1425 textPixel = 0;
1426 backgroundPixel = 1;
1427 } else {
1428 textPixel = 1;
1429 backgroundPixel = 0;
1430 }
1431 } else {
1432 textPixel = physDev->textPixel;
1433 backgroundPixel = physDev->backgroundPixel;
1434 }
1435
1436 if(flags & ETO_OPAQUE)
1437 {
1438 wine_tsx11_lock();
1439 XSetForeground( gdi_display, physDev->gc, backgroundPixel );
1440 XFillRectangle( gdi_display, physDev->drawable, physDev->gc,
1441 physDev->dc_rect.left + lprect->left, physDev->dc_rect.top + lprect->top,
1442 lprect->right - lprect->left, lprect->bottom - lprect->top );
1443 wine_tsx11_unlock();
1444 }
1445
1446 if(count == 0)
1447 {
1448 retv = TRUE;
1449 goto done_unlock;
1450 }
1451
1452
1453 GetObjectW(GetCurrentObject(physDev->hdc, OBJ_FONT), sizeof(lf), &lf);
1454 if(lf.lfEscapement != 0) {
1455 cosEsc = cos(lf.lfEscapement * M_PI / 1800);
1456 sinEsc = sin(lf.lfEscapement * M_PI / 1800);
1457 } else {
1458 cosEsc = 1;
1459 sinEsc = 0;
1460 }
1461
1462 if (flags & ETO_CLIPPED)
1463 {
1464 HRGN clip_region;
1465
1466 clip_region = CreateRectRgnIndirect( lprect );
1467 /* make a copy of the current device region */
1468 saved_region = CreateRectRgn( 0, 0, 0, 0 );
1469 CombineRgn( saved_region, physDev->region, 0, RGN_COPY );
1470 X11DRV_SetDeviceClipping( physDev, saved_region, clip_region );
1471 DeleteObject( clip_region );
1472 }
1473
1474 if(X11DRV_XRender_Installed) {
1475 if(!physDev->xrender->pict) {
1476 XRenderPictureAttributes pa;
1477 pa.subwindow_mode = IncludeInferiors;
1478
1479 wine_tsx11_lock();
1480 physDev->xrender->pict = pXRenderCreatePicture(gdi_display,
1481 physDev->drawable, dst_format->pict_format,
1482 CPSubwindowMode, &pa);
1483 wine_tsx11_unlock();
1484
1485 TRACE("allocing pict = %lx dc = %p drawable = %08lx\n",
1486 physDev->xrender->pict, hdc, physDev->drawable);
1487 } else {
1488 TRACE("using existing pict = %lx dc = %p drawable = %08lx\n",
1489 physDev->xrender->pict, hdc, physDev->drawable);
1490 }
1491
1492 if ((data = X11DRV_GetRegionData( physDev->region, 0 )))
1493 {
1494 wine_tsx11_lock();
1495 pXRenderSetPictureClipRectangles( gdi_display, physDev->xrender->pict,
1496 physDev->dc_rect.left, physDev->dc_rect.top,
1497 (XRectangle *)data->Buffer, data->rdh.nCount );
1498 wine_tsx11_unlock();
1499 HeapFree( GetProcessHeap(), 0, data );
1500 }
1501 }
1502
1503 EnterCriticalSection(&xrender_cs);
1504
1505 entry = glyphsetCache + physDev->xrender->cache_index;
1506 if( disable_antialias == FALSE )
1507 aa_type = entry->aa_default;
1508 formatEntry = entry->format[aa_type];
1509
1510 for(idx = 0; idx < count; idx++) {
1511 if( !formatEntry ) {
1512 UploadGlyph(physDev, wstr[idx], aa_type);
1513 /* re-evaluate antialias since aa_default may have changed */
1514 if( disable_antialias == FALSE )
1515 aa_type = entry->aa_default;
1516 formatEntry = entry->format[aa_type];
1517 } else if( wstr[idx] >= formatEntry->nrealized || formatEntry->realized[wstr[idx]] == FALSE) {
1518 UploadGlyph(physDev, wstr[idx], aa_type);
1519 }
1520 }
1521 if (!formatEntry)
1522 {
1523 WARN("could not upload requested glyphs\n");
1524 LeaveCriticalSection(&xrender_cs);
1525 goto done_unlock;
1526 }
1527
1528 TRACE("Writing %s at %d,%d\n", debugstr_wn(wstr,count),
1529 physDev->dc_rect.left + x, physDev->dc_rect.top + y);
1530
1531 if(X11DRV_XRender_Installed)
1532 {
1533 XGlyphElt16 *elts = HeapAlloc(GetProcessHeap(), 0, sizeof(XGlyphElt16) * count);
1534 INT offset = 0;
1535 POINT desired, current;
1536 int render_op = PictOpOver;
1537
1538 /* There's a bug in XRenderCompositeText that ignores the xDst and yDst parameters.
1539 So we pass zeros to the function and move to our starting position using the first
1540 element of the elts array. */
1541
1542 desired.x = physDev->dc_rect.left + x;
1543 desired.y = physDev->dc_rect.top + y;
1544 current.x = current.y = 0;
1545
1546 tile_pict = get_tile_pict(dst_format, physDev->textPixel);
1547
1548 /* FIXME the mapping of Text/BkColor onto 1 or 0 needs investigation.
1549 */
1550 if((dst_format->format == WXR_FORMAT_MONO) && (textPixel == 0))
1551 render_op = PictOpOutReverse; /* This gives us 'black' text */
1552
1553 for(idx = 0; idx < count; idx++)
1554 {
1555 elts[idx].glyphset = formatEntry->glyphset;
1556 elts[idx].chars = wstr + idx;
1557 elts[idx].nchars = 1;
1558 elts[idx].xOff = desired.x - current.x;
1559 elts[idx].yOff = desired.y - current.y;
1560
1561 current.x += (elts[idx].xOff + formatEntry->gis[wstr[idx]].xOff);
1562 current.y += (elts[idx].yOff + formatEntry->gis[wstr[idx]].yOff);
1563
1564 if(!lpDx)
1565 {
1566 desired.x += formatEntry->gis[wstr[idx]].xOff;
1567 desired.y += formatEntry->gis[wstr[idx]].yOff;
1568 }
1569 else
1570 {
1571 offset += lpDx[idx];
1572 desired.x = physDev->dc_rect.left + x + offset * cosEsc;
1573 desired.y = physDev->dc_rect.top + y - offset * sinEsc;
1574 }
1575 }
1576 wine_tsx11_lock();
1577 pXRenderCompositeText16(gdi_display, render_op,
1578 tile_pict,
1579 physDev->xrender->pict,
1580 formatEntry->font_format->pict_format,
1581 0, 0, 0, 0, elts, count);
1582 wine_tsx11_unlock();
1583 HeapFree(GetProcessHeap(), 0, elts);
1584 } else {
1585 INT offset = 0, xoff = 0, yoff = 0;
1586 wine_tsx11_lock();
1587 XSetForeground( gdi_display, physDev->gc, textPixel );
1588
1589 if(aa_type == AA_None || physDev->depth == 1)
1590 {
1591 void (* sharp_glyph_fn)(X11DRV_PDEVICE *, INT, INT, void *, XGlyphInfo *);
1592
1593 if(aa_type == AA_None)
1594 sharp_glyph_fn = SharpGlyphMono;
1595 else
1596 sharp_glyph_fn = SharpGlyphGray;
1597
1598 for(idx = 0; idx < count; idx++) {
1599 sharp_glyph_fn(physDev, physDev->dc_rect.left + x + xoff,
1600 physDev->dc_rect.top + y + yoff,
1601 formatEntry->bitmaps[wstr[idx]],
1602 &formatEntry->gis[wstr[idx]]);
1603 if(lpDx) {
1604 offset += lpDx[idx];
1605 xoff = offset * cosEsc;
1606 yoff = offset * -sinEsc;
1607 } else {
1608 xoff += formatEntry->gis[wstr[idx]].xOff;
1609 yoff += formatEntry->gis[wstr[idx]].yOff;
1610 }
1611 }
1612 } else {
1613 XImage *image;
1614 int image_x, image_y, image_off_x, image_off_y, image_w, image_h;
1615 RECT extents = {0, 0, 0, 0};
1616 POINT cur = {0, 0};
1617 int w = physDev->drawable_rect.right - physDev->drawable_rect.left;
1618 int h = physDev->drawable_rect.bottom - physDev->drawable_rect.top;
1619
1620 TRACE("drawable %dx%d\n", w, h);
1621
1622 for(idx = 0; idx < count; idx++) {
1623 if(extents.left > cur.x - formatEntry->gis[wstr[idx]].x)
1624 extents.left = cur.x - formatEntry->gis[wstr[idx]].x;
1625 if(extents.top > cur.y - formatEntry->gis[wstr[idx]].y)
1626 extents.top = cur.y - formatEntry->gis[wstr[idx]].y;
1627 if(extents.right < cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width)
1628 extents.right = cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width;
1629 if(extents.bottom < cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height)
1630 extents.bottom = cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height;
1631 if(lpDx) {
1632 offset += lpDx[idx];
1633 cur.x = offset * cosEsc;
1634 cur.y = offset * -sinEsc;
1635 } else {
1636 cur.x += formatEntry->gis[wstr[idx]].xOff;
1637 cur.y += formatEntry->gis[wstr[idx]].yOff;
1638 }
1639 }
1640 TRACE("glyph extents %d,%d - %d,%d drawable x,y %d,%d\n", extents.left, extents.top,
1641 extents.right, extents.bottom, physDev->dc_rect.left + x, physDev->dc_rect.top + y);
1642
1643 if(physDev->dc_rect.left + x + extents.left >= 0) {
1644 image_x = physDev->dc_rect.left + x + extents.left;
1645 image_off_x = 0;
1646 } else {
1647 image_x = 0;
1648 image_off_x = physDev->dc_rect.left + x + extents.left;
1649 }
1650 if(physDev->dc_rect.top + y + extents.top >= 0) {
1651 image_y = physDev->dc_rect.top + y + extents.top;
1652 image_off_y = 0;
1653 } else {
1654 image_y = 0;
1655 image_off_y = physDev->dc_rect.top + y + extents.top;
1656 }
1657 if(physDev->dc_rect.left + x + extents.right < w)
1658 image_w = physDev->dc_rect.left + x + extents.right - image_x;
1659 else
1660 image_w = w - image_x;
1661 if(physDev->dc_rect.top + y + extents.bottom < h)
1662 image_h = physDev->dc_rect.top + y + extents.bottom - image_y;
1663 else
1664 image_h = h - image_y;
1665
1666 if(image_w <= 0 || image_h <= 0) goto no_image;
1667
1668 X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
1669 image = XGetImage(gdi_display, physDev->drawable,
1670 image_x, image_y, image_w, image_h,
1671 AllPlanes, ZPixmap);
1672 X11DRV_check_error();
1673
1674 TRACE("XGetImage(%p, %x, %d, %d, %d, %d, %lx, %x) depth = %d rets %p\n",
1675 gdi_display, (int)physDev->drawable, image_x, image_y,
1676 image_w, image_h, AllPlanes, ZPixmap,
1677 physDev->depth, image);
1678 if(!image) {
1679 Pixmap xpm = XCreatePixmap(gdi_display, root_window, image_w, image_h,
1680 physDev->depth);
1681 GC gc;
1682 XGCValues gcv;
1683
1684 gcv.graphics_exposures = False;
1685 gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv);
1686 XCopyArea(gdi_display, physDev->drawable, xpm, gc, image_x, image_y,
1687 image_w, image_h, 0, 0);
1688 XFreeGC(gdi_display, gc);
1689 X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
1690 image = XGetImage(gdi_display, xpm, 0, 0, image_w, image_h, AllPlanes,
1691 ZPixmap);
1692 X11DRV_check_error();
1693 XFreePixmap(gdi_display, xpm);
1694 }
1695 if(!image) goto no_image;
1696
1697 image->red_mask = visual->red_mask;
1698 image->green_mask = visual->green_mask;
1699 image->blue_mask = visual->blue_mask;
1700
1701 offset = xoff = yoff = 0;
1702 for(idx = 0; idx < count; idx++) {
1703 SmoothGlyphGray(image, xoff + image_off_x - extents.left,
1704 yoff + image_off_y - extents.top,
1705 formatEntry->bitmaps[wstr[idx]],
1706 &formatEntry->gis[wstr[idx]],
1707 physDev->textPixel);
1708 if(lpDx) {
1709 offset += lpDx[idx];
1710 xoff = offset * cosEsc;
1711 yoff = offset * -sinEsc;
1712 } else {
1713 xoff += formatEntry->gis[wstr[idx]].xOff;
1714 yoff += formatEntry->gis[wstr[idx]].yOff;
1715 }
1716 }
1717 XPutImage(gdi_display, physDev->drawable, physDev->gc, image, 0, 0,
1718 image_x, image_y, image_w, image_h);
1719 XDestroyImage(image);
1720 }
1721 no_image:
1722 wine_tsx11_unlock();
1723 }
1724 LeaveCriticalSection(&xrender_cs);
1725
1726 if (flags & ETO_CLIPPED)
1727 {
1728 /* restore the device region */
1729 X11DRV_SetDeviceClipping( physDev, saved_region, 0 );
1730 DeleteObject( saved_region );
1731 }
1732
1733 retv = TRUE;
1734
1735 done_unlock:
1736 X11DRV_UnlockDIBSection( physDev, TRUE );
1737 return retv;
1738 }
1739
1740 /* Set the x/y scaling and x/y offsets in the transformation matrix of the source picture */
1741 static void set_xrender_transformation(Picture src_pict, float xscale, float yscale, int xoffset, int yoffset)
1742 {
1743 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
1744 XTransform xform = {{
1745 { XDoubleToFixed(xscale), XDoubleToFixed(0), XDoubleToFixed(xoffset) },
1746 { XDoubleToFixed(0), XDoubleToFixed(yscale), XDoubleToFixed(yoffset) },
1747 { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) }
1748 }};
1749
1750 pXRenderSetPictureTransform(gdi_display, src_pict, &xform);
1751 #endif
1752 }
1753
1754 /* Helper function for (stretched) blitting using xrender */
1755 static void xrender_blit(Picture src_pict, Picture mask_pict, Picture dst_pict, int x_src, int y_src, float xscale, float yscale, int width, int height)
1756 {
1757 /* Further down a transformation matrix is used for stretching and mirroring the source data.
1758 * xscale/yscale contain the scaling factors for the width and height. In case of mirroring
1759 * we also need a x- and y-offset because without the pixels will be in the wrong quadrant of the x-y plane.
1760 */
1761 int x_offset = (xscale<0) ? width : 0;
1762 int y_offset = (yscale<0) ? height : 0;
1763
1764 /* When we need to scale we perform scaling and source_x / source_y translation using a transformation matrix.
1765 * This is needed because XRender is inaccurate in combination with scaled source coordinates passed to XRenderComposite.
1766 * In all other cases we do use XRenderComposite for translation as it is faster than using a transformation matrix. */
1767 if(xscale != 1.0 || yscale != 1.0)
1768 {
1769 /* When we are using a mask, 'src_pict' contains a 1x1 picture for tiling, the actual source data is in mask_pict */
1770 if(mask_pict)
1771 set_xrender_transformation(mask_pict, xscale, yscale, x_offset, y_offset);
1772 else
1773 set_xrender_transformation(src_pict, xscale, yscale, x_src + x_offset, y_src + y_offset);
1774
1775 pXRenderComposite(gdi_display, PictOpSrc, src_pict, mask_pict, dst_pict, 0, 0, 0, 0, 0, 0, width, height);
1776 }
1777 else
1778 {
1779 /* When we are using a mask, 'src_pict' contains a 1x1 picture for tiling, the actual source data is in mask_pict */
1780 if(mask_pict)
1781 set_xrender_transformation(mask_pict, 1, 1, 0, 0);
1782 else
1783 set_xrender_transformation(src_pict, 1, 1, 0, 0);
1784
1785 pXRenderComposite(gdi_display, PictOpSrc, src_pict, mask_pict, dst_pict, x_src, y_src, 0, 0, 0, 0, width, height);
1786 }
1787 }
1788
1789 /******************************************************************************
1790 * AlphaBlend (x11drv.@)
1791 */
1792 BOOL CDECL X11DRV_AlphaBlend(X11DRV_PDEVICE *devDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
1793 X11DRV_PDEVICE *devSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc,
1794 BLENDFUNCTION blendfn)
1795 {
1796 XRenderPictureAttributes pa;
1797 Picture dst_pict, src_pict;
1798 Pixmap xpm;
1799 DIBSECTION dib;
1800 XImage *image;
1801 GC gc;
1802 XGCValues gcv;
1803 DWORD *dstbits, *data;
1804 int y, y2;
1805 POINT pts[2];
1806 BOOL top_down = FALSE;
1807 RGNDATA *rgndata;
1808 WineXRenderFormat *dst_format = get_xrender_format_from_color_shifts(devDst->depth, devDst->color_shifts);
1809 WineXRenderFormat *src_format;
1810 int repeat_src;
1811
1812 if(!X11DRV_XRender_Installed) {
1813 FIXME("Unable to AlphaBlend without Xrender\n");
1814 return FALSE;
1815 }
1816 pts[0].x = xDst;
1817 pts[0].y = yDst;
1818 pts[1].x = xDst + widthDst;
1819 pts[1].y = yDst + heightDst;
1820 LPtoDP(devDst->hdc, pts, 2);
1821 xDst = pts[0].x;
1822 yDst = pts[0].y;
1823 widthDst = pts[1].x - pts[0].x;
1824 heightDst = pts[1].y - pts[0].y;
1825
1826 pts[0].x = xSrc;
1827 pts[0].y = ySrc;
1828 pts[1].x = xSrc + widthSrc;
1829 pts[1].y = ySrc + heightSrc;
1830 LPtoDP(devSrc->hdc, pts, 2);
1831 xSrc = pts[0].x;
1832 ySrc = pts[0].y;
1833 widthSrc = pts[1].x - pts[0].x;
1834 heightSrc = pts[1].y - pts[0].y;
1835 if (!widthDst || !heightDst || !widthSrc || !heightSrc) return TRUE;
1836
1837 /* If the source is a 1x1 bitmap, tiling is equivalent to stretching, but
1838 tiling is much faster. Therefore, we do no stretching in this case. */
1839 repeat_src = widthSrc == 1 && heightSrc == 1;
1840
1841 #ifndef HAVE_XRENDERSETPICTURETRANSFORM
1842 if((widthDst != widthSrc || heightDst != heightSrc) && !repeat_src)
1843 #else
1844 if(!pXRenderSetPictureTransform && !repeat_src)
1845 #endif
1846 {
1847 FIXME("Unable to Stretch, XRenderSetPictureTransform is currently required\n");
1848 return FALSE;
1849 }
1850
1851 if (!devSrc->bitmap || GetObjectW( devSrc->bitmap->hbitmap, sizeof(dib), &dib ) != sizeof(dib))
1852 {
1853 static BOOL out = FALSE;
1854 if (!out)
1855 {
1856 FIXME("not a dibsection\n");
1857 out = TRUE;
1858 }
1859 return FALSE;
1860 }
1861
1862 if (xSrc < 0 || ySrc < 0 || widthSrc < 0 || heightSrc < 0 || xSrc + widthSrc > dib.dsBmih.biWidth
1863 || ySrc + heightSrc > abs(dib.dsBmih.biHeight))
1864 {
1865 WARN("Invalid src coords: (%d,%d), size %dx%d\n", xSrc, ySrc, widthSrc, heightSrc);
1866 SetLastError(ERROR_INVALID_PARAMETER);
1867 return FALSE;
1868 }
1869
1870 if ((blendfn.AlphaFormat & AC_SRC_ALPHA) && blendfn.SourceConstantAlpha != 0xff)
1871 FIXME("Ignoring SourceConstantAlpha %d for AC_SRC_ALPHA\n", blendfn.SourceConstantAlpha);
1872
1873 if(dib.dsBm.bmBitsPixel != 32) {
1874 FIXME("not a 32 bpp dibsection\n");
1875 return FALSE;
1876 }
1877 dstbits = data = HeapAlloc(GetProcessHeap(), 0, heightSrc * widthSrc * 4);
1878
1879 if(dib.dsBmih.biHeight < 0) { /* top-down dib */
1880 top_down = TRUE;
1881 dstbits += widthSrc * (heightSrc - 1);
1882 y2 = ySrc;
1883 y = y2 + heightSrc - 1;
1884 }
1885 else
1886 {
1887 y = dib.dsBmih.biHeight - ySrc - 1;
1888 y2 = y - heightSrc + 1;
1889 }
1890
1891 if (blendfn.AlphaFormat & AC_SRC_ALPHA)
1892 {
1893 for(; y >= y2; y--)
1894 {
1895 memcpy(dstbits, (char *)dib.dsBm.bmBits + y * dib.dsBm.bmWidthBytes + xSrc * 4,
1896 widthSrc * 4);
1897 dstbits += (top_down ? -1 : 1) * widthSrc;
1898 }
1899 }
1900 else
1901 {
1902 DWORD source_alpha = (DWORD)blendfn.SourceConstantAlpha << 24;
1903 int x;
1904
1905 for(; y >= y2; y--)
1906 {
1907 DWORD *srcbits = (DWORD *)((char *)dib.dsBm.bmBits + y * dib.dsBm.bmWidthBytes) + xSrc;
1908 for (x = 0; x < widthSrc; x++)
1909 {
1910 DWORD argb = *srcbits++;
1911 argb = (argb & 0xffffff) | source_alpha;
1912 *dstbits++ = argb;
1913 }
1914 if (top_down) /* we traversed the row forward so we should go back by two rows */
1915 dstbits -= 2 * widthSrc;
1916 }
1917
1918 }
1919
1920 rgndata = X11DRV_GetRegionData( devDst->region, 0 );
1921
1922 wine_tsx11_lock();
1923 image = XCreateImage(gdi_display, visual, 32, ZPixmap, 0,
1924 (char*) data, widthSrc, heightSrc, 32, widthSrc * 4);
1925
1926 src_format = get_xrender_format(WXR_FORMAT_A8R8G8B8);
1927 TRACE("src_format %p\n", src_format);
1928 if(!src_format)
1929 {
1930 WARN("Unable to find a picture format supporting alpha, make sure X is running at 24-bit\n");
1931 return FALSE;
1932 }
1933
1934 pa.subwindow_mode = IncludeInferiors;
1935 pa.repeat = repeat_src ? RepeatNormal : RepeatNone;
1936
1937 /* FIXME use devDst->xrender->pict ? */
1938 dst_pict = pXRenderCreatePicture(gdi_display,
1939 devDst->drawable,
1940 dst_format->pict_format,
1941 CPSubwindowMode, &pa);
1942 TRACE("dst_pict %08lx\n", dst_pict);
1943 TRACE("src_drawable = %08lx\n", devSrc->drawable);
1944 xpm = XCreatePixmap(gdi_display,
1945 root_window,
1946 widthSrc, heightSrc, 32);
1947 gcv.graphics_exposures = False;
1948 gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv);
1949 TRACE("xpm = %08lx\n", xpm);
1950 XPutImage(gdi_display, xpm, gc, image, 0, 0, 0, 0, widthSrc, heightSrc);
1951
1952 src_pict = pXRenderCreatePicture(gdi_display,
1953 xpm, src_format->pict_format,
1954 CPSubwindowMode|CPRepeat, &pa);
1955 TRACE("src_pict %08lx\n", src_pict);
1956
1957 if (rgndata)
1958 {
1959 pXRenderSetPictureClipRectangles( gdi_display, dst_pict,
1960 devDst->dc_rect.left, devDst->dc_rect.top,
1961 (XRectangle *)rgndata->Buffer,
1962 rgndata->rdh.nCount );
1963 HeapFree( GetProcessHeap(), 0, rgndata );
1964 }
1965
1966 /* Make sure we ALWAYS set the transformation matrix even if we don't need to scale. The reason is
1967 * that later on we want to reuse pictures (it can bring a lot of extra performance) and each time
1968 * a different transformation matrix might have been used. */
1969 set_xrender_transformation(src_pict, widthSrc/(double)widthDst, heightSrc/(double)heightDst, 0, 0);
1970 pXRenderComposite(gdi_display, PictOpOver, src_pict, 0, dst_pict,
1971 0, 0, 0, 0,
1972 xDst + devDst->dc_rect.left, yDst + devDst->dc_rect.top, widthDst, heightDst);
1973
1974
1975 pXRenderFreePicture(gdi_display, src_pict);
1976 XFreePixmap(gdi_display, xpm);
1977 XFreeGC(gdi_display, gc);
1978 pXRenderFreePicture(gdi_display, dst_pict);
1979 image->data = NULL;
1980 XDestroyImage(image);
1981
1982 wine_tsx11_unlock();
1983 HeapFree(GetProcessHeap(), 0, data);
1984 return TRUE;
1985 }
1986
1987 void X11DRV_XRender_CopyBrush(X11DRV_PDEVICE *physDev, X_PHYSBITMAP *physBitmap, int width, int height)
1988 {
1989 /* At depths >1, the depth of physBitmap and physDev might not be the same e.g. the physbitmap might be a 16-bit DIB while the physdev uses 24-bit */
1990 int depth = physBitmap->pixmap_depth == 1 ? 1 : physDev->depth;
1991
1992 wine_tsx11_lock();
1993 physDev->brush.pixmap = XCreatePixmap(gdi_display, root_window, width, height, depth);
1994
1995 /* Use XCopyArea when the physBitmap and brush.pixmap have the same depth. */
1996 if(physBitmap->pixmap_depth == 1 || physDev->depth == physBitmap->pixmap_depth)
1997 {
1998 XCopyArea( gdi_display, physBitmap->pixmap, physDev->brush.pixmap,
1999 get_bitmap_gc(physBitmap->pixmap_depth), 0, 0, width, height, 0, 0 );
2000 }
2001 else /* We meed depth conversion */
2002 {
2003 WineXRenderFormat *src_format = get_xrender_format_from_color_shifts(physBitmap->pixmap_depth, &physBitmap->pixmap_color_shifts);
2004 WineXRenderFormat *dst_format = get_xrender_format_from_color_shifts(physDev->depth, physDev->color_shifts);
2005
2006 Picture src_pict, dst_pict;
2007 XRenderPictureAttributes pa;
2008 pa.subwindow_mode = IncludeInferiors;
2009 pa.repeat = RepeatNone;
2010
2011 src_pict = pXRenderCreatePicture(gdi_display, physBitmap->pixmap, src_format->pict_format, CPSubwindowMode|CPRepeat, &pa);
2012 dst_pict = pXRenderCreatePicture(gdi_display, physDev->brush.pixmap, dst_format->pict_format, CPSubwindowMode|CPRepeat, &pa);
2013
2014 xrender_blit(src_pict, 0, dst_pict, 0, 0, 1.0, 1.0, width, height);
2015 pXRenderFreePicture(gdi_display, src_pict);
2016 pXRenderFreePicture(gdi_display, dst_pict);
2017 }
2018 wine_tsx11_unlock();
2019 }
2020
2021 BOOL X11DRV_XRender_GetSrcAreaStretch(X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
2022 Pixmap pixmap, GC gc,
2023 INT widthSrc, INT heightSrc,
2024 INT widthDst, INT heightDst,
2025 RECT *visRectSrc, RECT *visRectDst )
2026 {
2027 BOOL stretch = (widthSrc != widthDst) || (heightSrc != heightDst);
2028 int width = visRectDst->right - visRectDst->left;
2029 int height = visRectDst->bottom - visRectDst->top;
2030 int x_src = physDevSrc->dc_rect.left + visRectSrc->left;
2031 int y_src = physDevSrc->dc_rect.top + visRectSrc->top;
2032 WineXRenderFormat *src_format = get_xrender_format_from_color_shifts(physDevSrc->depth, physDevSrc->color_shifts);
2033 WineXRenderFormat *dst_format = get_xrender_format_from_color_shifts(physDevDst->depth, physDevDst->color_shifts);
2034 Picture src_pict=0, dst_pict=0, mask_pict=0;
2035
2036 double xscale = widthSrc/(double)widthDst;
2037 double yscale = heightSrc/(double)heightDst;
2038
2039 XRenderPictureAttributes pa;
2040 pa.subwindow_mode = IncludeInferiors;
2041 pa.repeat = RepeatNone;
2042
2043 TRACE("src depth=%d widthSrc=%d heightSrc=%d xSrc=%d ySrc=%d\n", physDevSrc->depth, widthSrc, heightSrc, x_src, y_src);
2044 TRACE("dst depth=%d widthDst=%d heightDst=%d\n", physDevDst->depth, widthDst, heightDst);
2045
2046 if(!X11DRV_XRender_Installed)
2047 {
2048 TRACE("Not using XRender since it is not available or disabled\n");
2049 return FALSE;
2050 }
2051
2052 /* XRender can't handle palettes, so abort */
2053 if(X11DRV_PALETTE_XPixelToPalette)
2054 return FALSE;
2055
2056 /* XRender is of no use in this case */
2057 if((physDevDst->depth == 1) && (physDevSrc->depth > 1))
2058 return FALSE;
2059
2060 /* Just use traditional X copy when the depths match and we don't need stretching */
2061 if((physDevSrc->depth == physDevDst->depth) && !stretch)
2062 {
2063 TRACE("Source and destination depth match and no stretching needed falling back to XCopyArea\n");
2064 wine_tsx11_lock();
2065 XCopyArea( gdi_display, physDevSrc->drawable, pixmap, gc, x_src, y_src, width, height, 0, 0);
2066 wine_tsx11_unlock();
2067 return TRUE;
2068 }
2069
2070 /* mono -> color */
2071 if(physDevSrc->depth == 1)
2072 {
2073 XRenderColor col;
2074 get_xrender_color(dst_format, physDevDst->textPixel, &col);
2075
2076 /* We use the source drawable as a mask */
2077 wine_tsx11_lock();
2078 mask_pict = pXRenderCreatePicture(gdi_display, physDevSrc->drawable, src_format->pict_format, CPSubwindowMode|CPRepeat, &pa);
2079
2080 /* Use backgroundPixel as the foreground color */
2081 src_pict = get_tile_pict(dst_format, physDevDst->backgroundPixel);
2082
2083 /* Create a destination picture and fill it with textPixel color as the background color */
2084 dst_pict = pXRenderCreatePicture(gdi_display, pixmap, dst_format->pict_format, CPSubwindowMode|CPRepeat, &pa);
2085 pXRenderFillRectangle(gdi_display, PictOpSrc, dst_pict, &col, 0, 0, width, height);
2086
2087 xrender_blit(src_pict, mask_pict, dst_pict, x_src, y_src, xscale, yscale, width, height);
2088
2089 if(dst_pict) pXRenderFreePicture(gdi_display, dst_pict);
2090 if(mask_pict) pXRenderFreePicture(gdi_display, mask_pict);
2091 wine_tsx11_unlock();
2092 }
2093 else /* color -> color but with different depths */
2094 {
2095 wine_tsx11_lock();
2096 src_pict = pXRenderCreatePicture(gdi_display,
2097 physDevSrc->drawable, src_format->pict_format,
2098 CPSubwindowMode|CPRepeat, &pa);
2099
2100 dst_pict = pXRenderCreatePicture(gdi_display,
2101 pixmap, dst_format->pict_format,
2102 CPSubwindowMode|CPRepeat, &pa);
2103
2104 xrender_blit(src_pict, 0, dst_pict, x_src, y_src, xscale, yscale, width, height);
2105
2106 if(src_pict) pXRenderFreePicture(gdi_display, src_pict);
2107 if(dst_pict) pXRenderFreePicture(gdi_display, dst_pict);
2108 wine_tsx11_unlock();
2109 }
2110 return TRUE;
2111 }
2112
2113 #else /* SONAME_LIBXRENDER */
2114
2115 void X11DRV_XRender_Init(void)
2116 {
2117 TRACE("XRender support not compiled in.\n");
2118 return;
2119 }
2120
2121 void X11DRV_XRender_Finalize(void)
2122 {
2123 }
2124
2125 BOOL X11DRV_XRender_SelectFont(X11DRV_PDEVICE *physDev, HFONT hfont)
2126 {
2127 assert(0);
2128 return FALSE;
2129 }
2130
2131 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE *physDev)
2132 {
2133 assert(0);
2134 return;
2135 }
2136
2137 BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags,
2138 const RECT *lprect, LPCWSTR wstr, UINT count,
2139 const INT *lpDx )
2140 {
2141 assert(0);
2142 return FALSE;
2143 }
2144
2145 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE *physDev)
2146 {
2147 assert(0);
2148 return;
2149 }
2150
2151 /******************************************************************************
2152 * AlphaBlend (x11drv.@)
2153 */
2154 BOOL X11DRV_AlphaBlend(X11DRV_PDEVICE *devDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
2155 X11DRV_PDEVICE *devSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc,
2156 BLENDFUNCTION blendfn)
2157 {
2158 FIXME("not supported - XRENDER headers were missing at compile time\n");
2159 return FALSE;
2160 }
2161
2162 void X11DRV_XRender_CopyBrush(X11DRV_PDEVICE *physDev, X_PHYSBITMAP *physBitmap, int width, int height)
2163 {
2164 wine_tsx11_lock();
2165 physDev->brush.pixmap = XCreatePixmap(gdi_display, root_window, width, height, physBitmap->pixmap_depth);
2166
2167 XCopyArea( gdi_display, physBitmap->pixmap, physDev->brush.pixmap,
2168 get_bitmap_gc(physBitmap->pixmap_depth), 0, 0, width, height, 0, 0 );
2169 wine_tsx11_unlock();
2170 }
2171
2172 BOOL X11DRV_XRender_GetSrcAreaStretch(X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
2173 Pixmap pixmap, GC gc,
2174 INT widthSrc, INT heightSrc,
2175 INT widthDst, INT heightDst,
2176 RECT *visRectSrc, RECT *visRectDst )
2177 {
2178 return FALSE;
2179 }
2180 #endif /* SONAME_LIBXRENDER */
useful hacks and other patches not (yet) suitable for mainline