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