?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
quartz: Free two assert calls from having side effects.
[wine/testsucceed.git] / dlls / winex11.drv / xrender.c
blob33ad4bd9c4f85abad0c96a7e3938c25d60b4f976
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 * Copyright 2011 Alexandre Julliard
7 *
8 * Some parts also:
9 * Copyright 2000 Keith Packard, member of The XFree86 Project, Inc.
10 *
11 * This library is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU Lesser General Public
13 * License as published by the Free Software Foundation; either
14 * version 2.1 of the License, or (at your option) any later version.
15 *
16 * This library is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * Lesser General Public License for more details.
20 *
21 * You should have received a copy of the GNU Lesser General Public
22 * License along with this library; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
24 */
25 #include "config.h"
26 #include "wine/port.h"
27
28 #include <assert.h>
29 #include <stdarg.h>
30 #include <string.h>
31 #include <stdlib.h>
32
33 #include "windef.h"
34 #include "winbase.h"
35 #include "x11drv.h"
36 #include "winternl.h"
37 #include "wine/library.h"
38 #include "wine/unicode.h"
39 #include "wine/debug.h"
40
41 int using_client_side_fonts = FALSE;
42
43 WINE_DEFAULT_DEBUG_CHANNEL(xrender);
44
45 #ifdef SONAME_LIBXRENDER
46
47 static BOOL X11DRV_XRender_Installed = FALSE;
48
49 #include <X11/Xlib.h>
50 #include <X11/extensions/Xrender.h>
51
52 #ifndef RepeatNone /* added in 0.10 */
53 #define RepeatNone 0
54 #define RepeatNormal 1
55 #define RepeatPad 2
56 #define RepeatReflect 3
57 #endif
58
59 enum wxr_format
60 {
61 WXR_FORMAT_MONO,
62 WXR_FORMAT_GRAY,
63 WXR_FORMAT_X1R5G5B5,
64 WXR_FORMAT_X1B5G5R5,
65 WXR_FORMAT_R5G6B5,
66 WXR_FORMAT_B5G6R5,
67 WXR_FORMAT_R8G8B8,
68 WXR_FORMAT_B8G8R8,
69 WXR_FORMAT_A8R8G8B8,
70 WXR_FORMAT_B8G8R8A8,
71 WXR_FORMAT_X8R8G8B8,
72 WXR_FORMAT_B8G8R8X8,
73 WXR_NB_FORMATS,
74 WXR_INVALID_FORMAT = WXR_NB_FORMATS
75 };
76
77 typedef struct wine_xrender_format_template
78 {
79 unsigned int depth;
80 unsigned int alpha;
81 unsigned int alphaMask;
82 unsigned int red;
83 unsigned int redMask;
84 unsigned int green;
85 unsigned int greenMask;
86 unsigned int blue;
87 unsigned int blueMask;
88 } WineXRenderFormatTemplate;
89
90 static const WineXRenderFormatTemplate wxr_formats_template[WXR_NB_FORMATS] =
91 {
92 /* Format depth alpha mask red mask green mask blue mask*/
93 /* WXR_FORMAT_MONO */ { 1, 0, 0x01, 0, 0, 0, 0, 0, 0 },
94 /* WXR_FORMAT_GRAY */ { 8, 0, 0xff, 0, 0, 0, 0, 0, 0 },
95 /* WXR_FORMAT_X1R5G5B5 */ { 16, 0, 0, 10, 0x1f, 5, 0x1f, 0, 0x1f },
96 /* WXR_FORMAT_X1B5G5R5 */ { 16, 0, 0, 0, 0x1f, 5, 0x1f, 10, 0x1f },
97 /* WXR_FORMAT_R5G6B5 */ { 16, 0, 0, 11, 0x1f, 5, 0x3f, 0, 0x1f },
98 /* WXR_FORMAT_B5G6R5 */ { 16, 0, 0, 0, 0x1f, 5, 0x3f, 11, 0x1f },
99 /* WXR_FORMAT_R8G8B8 */ { 24, 0, 0, 16, 0xff, 8, 0xff, 0, 0xff },
100 /* WXR_FORMAT_B8G8R8 */ { 24, 0, 0, 0, 0xff, 8, 0xff, 16, 0xff },
101 /* WXR_FORMAT_A8R8G8B8 */ { 32, 24, 0xff, 16, 0xff, 8, 0xff, 0, 0xff },
102 /* WXR_FORMAT_B8G8R8A8 */ { 32, 0, 0xff, 8, 0xff, 16, 0xff, 24, 0xff },
103 /* WXR_FORMAT_X8R8G8B8 */ { 32, 0, 0, 16, 0xff, 8, 0xff, 0, 0xff },
104 /* WXR_FORMAT_B8G8R8X8 */ { 32, 0, 0, 8, 0xff, 16, 0xff, 24, 0xff },
105 };
106
107 static const ColorShifts wxr_color_shifts[WXR_NB_FORMATS] =
108 {
109 /* format phys red phys green phys blue log red log green log blue */
110 /* WXR_FORMAT_MONO */ { { 0,0,0 }, { 0,0,0 }, { 0,0,0 }, { 0,0,0 }, { 0,0,0 }, { 0,0,0 } },
111 /* WXR_FORMAT_GRAY */ { { 0,0,0 }, { 0,0,0 }, { 0,0,0 }, { 0,0,0 }, { 0,0,0 }, { 0,0,0 } },
112 /* WXR_FORMAT_X1R5G5B5 */ { {10,5,31}, { 5,5,31}, { 0,5,31}, {10,5,31}, { 5,5,31}, { 0,5,31} },
113 /* WXR_FORMAT_X1B5G5R5 */ { { 0,5,31}, { 5,5,31}, {10,5,31}, { 0,5,31}, { 5,5,31}, {10,5,31} },
114 /* WXR_FORMAT_R5G6B5 */ { {11,5,31}, { 5,6,63}, { 0,5,31}, {11,5,31}, { 5,6,63}, { 0,5,31} },
115 /* WXR_FORMAT_B5G6R5 */ { { 0,5,31}, { 5,6,63}, {11,5,31}, { 0,5,31}, { 5,6,63}, {11,5,31} },
116 /* WXR_FORMAT_R8G8B8 */ { {16,8,255}, { 8,8,255}, { 0,8,255}, {16,8,255}, { 8,8,255}, { 0,8,255} },
117 /* WXR_FORMAT_B8G8R8 */ { { 0,8,255}, { 8,8,255}, {16,8,255}, { 0,8,255}, { 8,8,255}, {16,8,255} },
118 /* WXR_FORMAT_A8R8G8B8 */ { {16,8,255}, { 8,8,255}, { 0,8,255}, {16,8,255}, { 8,8,255}, { 0,8,255} },
119 /* WXR_FORMAT_B8G8R8A8 */ { { 8,8,255}, {16,8,255}, {24,8,255}, { 8,8,255}, {16,8,255}, {24,8,255} },
120 /* WXR_FORMAT_X8R8G8B8 */ { {16,8,255}, { 8,8,255}, { 0,8,255}, {16,8,255}, { 8,8,255}, { 0,8,255} },
121 /* WXR_FORMAT_B8G8R8X8 */ { { 8,8,255}, {16,8,255}, {24,8,255}, { 8,8,255}, {16,8,255}, {24,8,255} },
122 };
123
124 static enum wxr_format default_format = WXR_INVALID_FORMAT;
125 static XRenderPictFormat *pict_formats[WXR_NB_FORMATS + 1 /* invalid format */];
126
127 typedef struct
128 {
129 LOGFONTW lf;
130 XFORM xform;
131 SIZE devsize; /* size in device coords */
132 DWORD hash;
133 } LFANDSIZE;
134
135 #define INITIAL_REALIZED_BUF_SIZE 128
136
137 typedef enum { AA_None = 0, AA_Grey, AA_RGB, AA_BGR, AA_VRGB, AA_VBGR, AA_MAXVALUE } AA_Type;
138
139 typedef struct
140 {
141 GlyphSet glyphset;
142 XRenderPictFormat *font_format;
143 int nrealized;
144 BOOL *realized;
145 void **bitmaps;
146 XGlyphInfo *gis;
147 } gsCacheEntryFormat;
148
149 typedef struct
150 {
151 LFANDSIZE lfsz;
152 AA_Type aa_default;
153 gsCacheEntryFormat * format[AA_MAXVALUE];
154 INT count;
155 INT next;
156 } gsCacheEntry;
157
158 struct xrender_physdev
159 {
160 struct gdi_physdev dev;
161 X11DRV_PDEVICE *x11dev;
162 enum wxr_format format;
163 int cache_index;
164 BOOL update_clip;
165 Picture pict;
166 Picture pict_src;
167 XRenderPictFormat *pict_format;
168 };
169
170 static inline struct xrender_physdev *get_xrender_dev( PHYSDEV dev )
171 {
172 return (struct xrender_physdev *)dev;
173 }
174
175 static const struct gdi_dc_funcs xrender_funcs;
176
177 static gsCacheEntry *glyphsetCache = NULL;
178 static DWORD glyphsetCacheSize = 0;
179 static INT lastfree = -1;
180 static INT mru = -1;
181
182 #define INIT_CACHE_SIZE 10
183
184 static int antialias = 1;
185
186 static void *xrender_handle;
187
188 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
189 MAKE_FUNCPTR(XRenderAddGlyphs)
190 MAKE_FUNCPTR(XRenderComposite)
191 MAKE_FUNCPTR(XRenderCompositeText16)
192 MAKE_FUNCPTR(XRenderCreateGlyphSet)
193 MAKE_FUNCPTR(XRenderCreatePicture)
194 MAKE_FUNCPTR(XRenderFillRectangle)
195 MAKE_FUNCPTR(XRenderFindFormat)
196 MAKE_FUNCPTR(XRenderFindVisualFormat)
197 MAKE_FUNCPTR(XRenderFreeGlyphSet)
198 MAKE_FUNCPTR(XRenderFreePicture)
199 MAKE_FUNCPTR(XRenderSetPictureClipRectangles)
200 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
201 MAKE_FUNCPTR(XRenderSetPictureTransform)
202 #endif
203 MAKE_FUNCPTR(XRenderQueryExtension)
204
205 #ifdef SONAME_LIBFONTCONFIG
206 #include <fontconfig/fontconfig.h>
207 MAKE_FUNCPTR(FcConfigSubstitute)
208 MAKE_FUNCPTR(FcDefaultSubstitute)
209 MAKE_FUNCPTR(FcFontMatch)
210 MAKE_FUNCPTR(FcInit)
211 MAKE_FUNCPTR(FcPatternCreate)
212 MAKE_FUNCPTR(FcPatternDestroy)
213 MAKE_FUNCPTR(FcPatternAddInteger)
214 MAKE_FUNCPTR(FcPatternAddString)
215 MAKE_FUNCPTR(FcPatternGetBool)
216 MAKE_FUNCPTR(FcPatternGetInteger)
217 MAKE_FUNCPTR(FcPatternGetString)
218 static void *fontconfig_handle;
219 static BOOL fontconfig_installed;
220 #endif
221
222 #undef MAKE_FUNCPTR
223
224 static CRITICAL_SECTION xrender_cs;
225 static CRITICAL_SECTION_DEBUG critsect_debug =
226 {
227 0, 0, &xrender_cs,
228 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
229 0, 0, { (DWORD_PTR)(__FILE__ ": xrender_cs") }
230 };
231 static CRITICAL_SECTION xrender_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
232
233 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
234 ( ( (ULONG)_x4 << 24 ) | \
235 ( (ULONG)_x3 << 16 ) | \
236 ( (ULONG)_x2 << 8 ) | \
237 (ULONG)_x1 )
238
239 #define MS_GASP_TAG MS_MAKE_TAG('g', 'a', 's', 'p')
240
241 #define GASP_GRIDFIT 0x01
242 #define GASP_DOGRAY 0x02
243
244 #ifdef WORDS_BIGENDIAN
245 #define get_be_word(x) (x)
246 #define NATIVE_BYTE_ORDER MSBFirst
247 #else
248 #define get_be_word(x) RtlUshortByteSwap(x)
249 #define NATIVE_BYTE_ORDER LSBFirst
250 #endif
251
252 static BOOL has_alpha( enum wxr_format format )
253 {
254 return (format == WXR_FORMAT_A8R8G8B8 || format == WXR_FORMAT_B8G8R8A8);
255 }
256
257 static enum wxr_format get_format_without_alpha( enum wxr_format format )
258 {
259 switch (format)
260 {
261 case WXR_FORMAT_A8R8G8B8: return WXR_FORMAT_X8R8G8B8;
262 case WXR_FORMAT_B8G8R8A8: return WXR_FORMAT_B8G8R8X8;
263 default: return format;
264 }
265 }
266
267 static BOOL get_xrender_template(const WineXRenderFormatTemplate *fmt, XRenderPictFormat *templ, unsigned long *mask)
268 {
269 templ->id = 0;
270 templ->type = PictTypeDirect;
271 templ->depth = fmt->depth;
272 templ->direct.alpha = fmt->alpha;
273 templ->direct.alphaMask = fmt->alphaMask;
274 templ->direct.red = fmt->red;
275 templ->direct.redMask = fmt->redMask;
276 templ->direct.green = fmt->green;
277 templ->direct.greenMask = fmt->greenMask;
278 templ->direct.blue = fmt->blue;
279 templ->direct.blueMask = fmt->blueMask;
280 templ->colormap = 0;
281
282 *mask = PictFormatType | PictFormatDepth | PictFormatAlpha | PictFormatAlphaMask | PictFormatRed | PictFormatRedMask | PictFormatGreen | PictFormatGreenMask | PictFormatBlue | PictFormatBlueMask;
283
284 return TRUE;
285 }
286
287 static BOOL is_wxrformat_compatible_with_default_visual(const WineXRenderFormatTemplate *fmt)
288 {
289 if(fmt->depth != screen_depth)
290 return FALSE;
291 if( (fmt->redMask << fmt->red) != visual->red_mask)
292 return FALSE;
293 if( (fmt->greenMask << fmt->green) != visual->green_mask)
294 return FALSE;
295 if( (fmt->blueMask << fmt->blue) != visual->blue_mask)
296 return FALSE;
297
298 /* We never select a default ARGB visual */
299 if(fmt->alphaMask)
300 return FALSE;
301
302 return TRUE;
303 }
304
305 static int load_xrender_formats(void)
306 {
307 int count = 0;
308 unsigned int i;
309
310 for (i = 0; i < WXR_NB_FORMATS; i++)
311 {
312 XRenderPictFormat templ;
313
314 if(is_wxrformat_compatible_with_default_visual(&wxr_formats_template[i]))
315 {
316 wine_tsx11_lock();
317 pict_formats[i] = pXRenderFindVisualFormat(gdi_display, visual);
318 if (!pict_formats[i])
319 {
320 /* Xrender doesn't like DirectColor visuals, try to find a TrueColor one instead */
321 if (visual->class == DirectColor)
322 {
323 XVisualInfo info;
324 if (XMatchVisualInfo( gdi_display, DefaultScreen(gdi_display),
325 screen_depth, TrueColor, &info ))
326 {
327 pict_formats[i] = pXRenderFindVisualFormat(gdi_display, info.visual);
328 if (pict_formats[i]) visual = info.visual;
329 }
330 }
331 }
332 wine_tsx11_unlock();
333 if (pict_formats[i]) default_format = i;
334 }
335 else
336 {
337 unsigned long mask = 0;
338 get_xrender_template(&wxr_formats_template[i], &templ, &mask);
339
340 wine_tsx11_lock();
341 pict_formats[i] = pXRenderFindFormat(gdi_display, mask, &templ, 0);
342 wine_tsx11_unlock();
343 }
344 if (pict_formats[i])
345 {
346 count++;
347 TRACE("Loaded pict_format with id=%#lx for wxr_format=%#x\n", pict_formats[i]->id, i);
348 }
349 }
350 return count;
351 }
352
353 /***********************************************************************
354 * X11DRV_XRender_Init
355 *
356 * Let's see if our XServer has the extension available
357 *
358 */
359 const struct gdi_dc_funcs *X11DRV_XRender_Init(void)
360 {
361 int event_base, i;
362
363 if (client_side_with_render &&
364 (xrender_handle = wine_dlopen(SONAME_LIBXRENDER, RTLD_NOW, NULL, 0)))
365 {
366
367 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(xrender_handle, #f, NULL, 0)) == NULL) goto sym_not_found;
368 LOAD_FUNCPTR(XRenderAddGlyphs)
369 LOAD_FUNCPTR(XRenderComposite)
370 LOAD_FUNCPTR(XRenderCompositeText16)
371 LOAD_FUNCPTR(XRenderCreateGlyphSet)
372 LOAD_FUNCPTR(XRenderCreatePicture)
373 LOAD_FUNCPTR(XRenderFillRectangle)
374 LOAD_FUNCPTR(XRenderFindFormat)
375 LOAD_FUNCPTR(XRenderFindVisualFormat)
376 LOAD_FUNCPTR(XRenderFreeGlyphSet)
377 LOAD_FUNCPTR(XRenderFreePicture)
378 LOAD_FUNCPTR(XRenderSetPictureClipRectangles)
379 LOAD_FUNCPTR(XRenderQueryExtension)
380 #undef LOAD_FUNCPTR
381 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
382 #define LOAD_OPTIONAL_FUNCPTR(f) p##f = wine_dlsym(xrender_handle, #f, NULL, 0);
383 LOAD_OPTIONAL_FUNCPTR(XRenderSetPictureTransform)
384 #undef LOAD_OPTIONAL_FUNCPTR
385 #endif
386
387 wine_tsx11_lock();
388 X11DRV_XRender_Installed = pXRenderQueryExtension(gdi_display, &event_base, &xrender_error_base);
389 wine_tsx11_unlock();
390 if(X11DRV_XRender_Installed) {
391 TRACE("Xrender is up and running error_base = %d\n", xrender_error_base);
392 if(!load_xrender_formats()) /* This fails in buggy versions of libXrender.so */
393 {
394 wine_tsx11_unlock();
395 WINE_MESSAGE(
396 "Wine has detected that you probably have a buggy version\n"
397 "of libXrender.so . Because of this client side font rendering\n"
398 "will be disabled. Please upgrade this library.\n");
399 X11DRV_XRender_Installed = FALSE;
400 return NULL;
401 }
402
403 if (!visual->red_mask || !visual->green_mask || !visual->blue_mask) {
404 WARN("one or more of the colour masks are 0, disabling XRENDER. Try running in 16-bit mode or higher.\n");
405 X11DRV_XRender_Installed = FALSE;
406 }
407 }
408 }
409
410 #ifdef SONAME_LIBFONTCONFIG
411 if ((fontconfig_handle = wine_dlopen(SONAME_LIBFONTCONFIG, RTLD_NOW, NULL, 0)))
412 {
413 #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;}
414 LOAD_FUNCPTR(FcConfigSubstitute);
415 LOAD_FUNCPTR(FcDefaultSubstitute);
416 LOAD_FUNCPTR(FcFontMatch);
417 LOAD_FUNCPTR(FcInit);
418 LOAD_FUNCPTR(FcPatternCreate);
419 LOAD_FUNCPTR(FcPatternDestroy);
420 LOAD_FUNCPTR(FcPatternAddInteger);
421 LOAD_FUNCPTR(FcPatternAddString);
422 LOAD_FUNCPTR(FcPatternGetBool);
423 LOAD_FUNCPTR(FcPatternGetInteger);
424 LOAD_FUNCPTR(FcPatternGetString);
425 #undef LOAD_FUNCPTR
426 fontconfig_installed = pFcInit();
427 }
428 else TRACE( "cannot find the fontconfig library " SONAME_LIBFONTCONFIG "\n" );
429 #endif
430
431 sym_not_found:
432 if(X11DRV_XRender_Installed || client_side_with_core)
433 {
434 glyphsetCache = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
435 sizeof(*glyphsetCache) * INIT_CACHE_SIZE);
436
437 glyphsetCacheSize = INIT_CACHE_SIZE;
438 lastfree = 0;
439 for(i = 0; i < INIT_CACHE_SIZE; i++) {
440 glyphsetCache[i].next = i + 1;
441 glyphsetCache[i].count = -1;
442 }
443 glyphsetCache[i-1].next = -1;
444 using_client_side_fonts = 1;
445
446 if(!X11DRV_XRender_Installed) {
447 TRACE("Xrender is not available on your XServer, client side rendering with the core protocol instead.\n");
448 if(screen_depth <= 8 || !client_side_antialias_with_core)
449 antialias = 0;
450 } else {
451 if(screen_depth <= 8 || !client_side_antialias_with_render)
452 antialias = 0;
453 }
454 return &xrender_funcs;
455 }
456 TRACE("Using X11 core fonts\n");
457 return NULL;
458 }
459
460 /* Helper function to convert from a color packed in a 32-bit integer to a XRenderColor */
461 static void get_xrender_color( XRenderPictFormat *pf, int src_color, XRenderColor *dst_color )
462 {
463 if(pf->direct.redMask)
464 dst_color->red = ((src_color >> pf->direct.red) & pf->direct.redMask) * 65535/pf->direct.redMask;
465 else
466 dst_color->red = 0;
467
468 if(pf->direct.greenMask)
469 dst_color->green = ((src_color >> pf->direct.green) & pf->direct.greenMask) * 65535/pf->direct.greenMask;
470 else
471 dst_color->green = 0;
472
473 if(pf->direct.blueMask)
474 dst_color->blue = ((src_color >> pf->direct.blue) & pf->direct.blueMask) * 65535/pf->direct.blueMask;
475 else
476 dst_color->blue = 0;
477
478 dst_color->alpha = 0xffff;
479 }
480
481 static enum wxr_format get_xrender_format_from_color_shifts(int depth, ColorShifts *shifts)
482 {
483 int redMask, greenMask, blueMask;
484 unsigned int i;
485
486 if (depth == 1) return WXR_FORMAT_MONO;
487
488 /* physDevs of a depth <=8, don't have color_shifts set and XRender can't handle those except for 1-bit */
489 if (!shifts) return default_format;
490
491 redMask = shifts->physicalRed.max << shifts->physicalRed.shift;
492 greenMask = shifts->physicalGreen.max << shifts->physicalGreen.shift;
493 blueMask = shifts->physicalBlue.max << shifts->physicalBlue.shift;
494
495 /* Try to locate a format which matches the specification of the dibsection. */
496 for(i = 0; i < WXR_NB_FORMATS; i++)
497 {
498 if( depth == wxr_formats_template[i].depth &&
499 redMask == (wxr_formats_template[i].redMask << wxr_formats_template[i].red) &&
500 greenMask == (wxr_formats_template[i].greenMask << wxr_formats_template[i].green) &&
501 blueMask == (wxr_formats_template[i].blueMask << wxr_formats_template[i].blue) )
502 return i;
503 }
504
505 /* This should not happen because when we reach 'shifts' must have been set and we only allows shifts which are backed by X */
506 ERR("No XRender format found for %u %08x/%08x/%08x\n", depth, redMask, greenMask, blueMask);
507 return WXR_INVALID_FORMAT;
508 }
509
510 static enum wxr_format get_xrender_format_from_bitmapinfo( const BITMAPINFO *info, BOOL use_alpha )
511 {
512 if (info->bmiHeader.biPlanes != 1) return WXR_INVALID_FORMAT;
513
514 switch (info->bmiHeader.biBitCount)
515 {
516 case 1:
517 return WXR_FORMAT_MONO;
518 case 4:
519 case 8:
520 break;
521 case 24:
522 if (info->bmiHeader.biCompression != BI_RGB) break;
523 return WXR_FORMAT_R8G8B8;
524 case 16:
525 case 32:
526 if (info->bmiHeader.biCompression == BI_BITFIELDS)
527 {
528 DWORD *colors = (DWORD *)((char *)info + info->bmiHeader.biSize);
529 unsigned int i;
530
531 for (i = 0; i < WXR_NB_FORMATS; i++)
532 {
533 if (info->bmiHeader.biBitCount == wxr_formats_template[i].depth &&
534 colors[0] == (wxr_formats_template[i].redMask << wxr_formats_template[i].red) &&
535 colors[1] == (wxr_formats_template[i].greenMask << wxr_formats_template[i].green) &&
536 colors[2] == (wxr_formats_template[i].blueMask << wxr_formats_template[i].blue))
537 return i;
538 }
539 break;
540 }
541 if (info->bmiHeader.biCompression != BI_RGB) break;
542 if (info->bmiHeader.biBitCount == 16) return WXR_FORMAT_X1R5G5B5;
543 return use_alpha ? WXR_FORMAT_A8R8G8B8 : WXR_FORMAT_X8R8G8B8;
544 }
545 return WXR_INVALID_FORMAT;
546 }
547
548 /* Set the x/y scaling and x/y offsets in the transformation matrix of the source picture */
549 static void set_xrender_transformation(Picture src_pict, double xscale, double yscale, int xoffset, int yoffset)
550 {
551 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
552 XTransform xform = {{
553 { XDoubleToFixed(xscale), XDoubleToFixed(0), XDoubleToFixed(xoffset) },
554 { XDoubleToFixed(0), XDoubleToFixed(yscale), XDoubleToFixed(yoffset) },
555 { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) }
556 }};
557
558 pXRenderSetPictureTransform(gdi_display, src_pict, &xform);
559 #endif
560 }
561
562 /* check if we can use repeating instead of scaling for the specified source DC */
563 static BOOL use_source_repeat( struct xrender_physdev *dev )
564 {
565 return (dev->x11dev->bitmap &&
566 dev->x11dev->drawable_rect.right - dev->x11dev->drawable_rect.left == 1 &&
567 dev->x11dev->drawable_rect.bottom - dev->x11dev->drawable_rect.top == 1);
568 }
569
570 static Picture get_xrender_picture( struct xrender_physdev *dev, HRGN clip_rgn, const RECT *clip_rect )
571 {
572 if (!dev->pict && dev->pict_format)
573 {
574 XRenderPictureAttributes pa;
575
576 wine_tsx11_lock();
577 pa.subwindow_mode = IncludeInferiors;
578 dev->pict = pXRenderCreatePicture( gdi_display, dev->x11dev->drawable,
579 dev->pict_format, CPSubwindowMode, &pa );
580 wine_tsx11_unlock();
581 TRACE( "Allocing pict=%lx dc=%p drawable=%08lx\n",
582 dev->pict, dev->dev.hdc, dev->x11dev->drawable );
583 dev->update_clip = TRUE;
584 }
585
586 if (dev->update_clip)
587 {
588 RGNDATA *clip_data;
589 HRGN rgn = 0;
590
591 if (clip_rect)
592 {
593 rgn = CreateRectRgnIndirect( clip_rect );
594 if (clip_rgn) CombineRgn( rgn, rgn, clip_rgn, RGN_AND );
595 CombineRgn( rgn, rgn, dev->x11dev->region, RGN_AND );
596 }
597 else if (clip_rgn)
598 {
599 rgn = CreateRectRgn( 0, 0, 0, 0 );
600 CombineRgn( rgn, clip_rgn, dev->x11dev->region, RGN_AND );
601 }
602
603 if ((clip_data = X11DRV_GetRegionData( rgn ? rgn : dev->x11dev->region, 0 )))
604 {
605 wine_tsx11_lock();
606 pXRenderSetPictureClipRectangles( gdi_display, dev->pict,
607 dev->x11dev->dc_rect.left, dev->x11dev->dc_rect.top,
608 (XRectangle *)clip_data->Buffer, clip_data->rdh.nCount );
609 wine_tsx11_unlock();
610 HeapFree( GetProcessHeap(), 0, clip_data );
611 }
612 dev->update_clip = (rgn != 0); /* have to update again if we are using a custom region */
613 if (rgn) DeleteObject( rgn );
614 }
615 return dev->pict;
616 }
617
618 static Picture get_xrender_picture_source( struct xrender_physdev *dev, BOOL repeat )
619 {
620 if (!dev->pict_src && dev->pict_format)
621 {
622 XRenderPictureAttributes pa;
623
624 wine_tsx11_lock();
625 pa.subwindow_mode = IncludeInferiors;
626 pa.repeat = repeat ? RepeatNormal : RepeatNone;
627 dev->pict_src = pXRenderCreatePicture( gdi_display, dev->x11dev->drawable,
628 dev->pict_format, CPSubwindowMode|CPRepeat, &pa );
629 wine_tsx11_unlock();
630
631 TRACE("Allocing pict_src=%lx dc=%p drawable=%08lx repeat=%u\n",
632 dev->pict_src, dev->dev.hdc, dev->x11dev->drawable, pa.repeat);
633 }
634
635 return dev->pict_src;
636 }
637
638 static void free_xrender_picture( struct xrender_physdev *dev )
639 {
640 if (dev->pict || dev->pict_src)
641 {
642 wine_tsx11_lock();
643 XFlush( gdi_display );
644 if (dev->pict)
645 {
646 TRACE("freeing pict = %lx dc = %p\n", dev->pict, dev->dev.hdc);
647 pXRenderFreePicture(gdi_display, dev->pict);
648 dev->pict = 0;
649 }
650 if(dev->pict_src)
651 {
652 TRACE("freeing pict = %lx dc = %p\n", dev->pict_src, dev->dev.hdc);
653 pXRenderFreePicture(gdi_display, dev->pict_src);
654 dev->pict_src = 0;
655 }
656 wine_tsx11_unlock();
657 }
658 }
659
660 /* return a mask picture used to force alpha to 0 */
661 static Picture get_no_alpha_mask(void)
662 {
663 static Pixmap pixmap;
664 static Picture pict;
665
666 wine_tsx11_lock();
667 if (!pict)
668 {
669 XRenderPictureAttributes pa;
670 XRenderColor col;
671
672 pixmap = XCreatePixmap( gdi_display, root_window, 1, 1, 32 );
673 pa.repeat = RepeatNormal;
674 pa.component_alpha = True;
675 pict = pXRenderCreatePicture( gdi_display, pixmap, pict_formats[WXR_FORMAT_A8R8G8B8],
676 CPRepeat|CPComponentAlpha, &pa );
677 col.red = col.green = col.blue = 0xffff;
678 col.alpha = 0;
679 pXRenderFillRectangle( gdi_display, PictOpSrc, pict, &col, 0, 0, 1, 1 );
680 }
681 wine_tsx11_unlock();
682 return pict;
683 }
684
685 static BOOL fontcmp(LFANDSIZE *p1, LFANDSIZE *p2)
686 {
687 if(p1->hash != p2->hash) return TRUE;
688 if(memcmp(&p1->devsize, &p2->devsize, sizeof(p1->devsize))) return TRUE;
689 if(memcmp(&p1->xform, &p2->xform, sizeof(p1->xform))) return TRUE;
690 if(memcmp(&p1->lf, &p2->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE;
691 return strcmpiW(p1->lf.lfFaceName, p2->lf.lfFaceName);
692 }
693
694 #if 0
695 static void walk_cache(void)
696 {
697 int i;
698
699 EnterCriticalSection(&xrender_cs);
700 for(i=mru; i >= 0; i = glyphsetCache[i].next)
701 TRACE("item %d\n", i);
702 LeaveCriticalSection(&xrender_cs);
703 }
704 #endif
705
706 static int LookupEntry(LFANDSIZE *plfsz)
707 {
708 int i, prev_i = -1;
709
710 for(i = mru; i >= 0; i = glyphsetCache[i].next) {
711 TRACE("%d\n", i);
712 if(glyphsetCache[i].count == -1) break; /* reached free list so stop */
713
714 if(!fontcmp(&glyphsetCache[i].lfsz, plfsz)) {
715 glyphsetCache[i].count++;
716 if(prev_i >= 0) {
717 glyphsetCache[prev_i].next = glyphsetCache[i].next;
718 glyphsetCache[i].next = mru;
719 mru = i;
720 }
721 TRACE("found font in cache %d\n", i);
722 return i;
723 }
724 prev_i = i;
725 }
726 TRACE("font not in cache\n");
727 return -1;
728 }
729
730 static void FreeEntry(int entry)
731 {
732 int i, format;
733
734 for(format = 0; format < AA_MAXVALUE; format++) {
735 gsCacheEntryFormat * formatEntry;
736
737 if( !glyphsetCache[entry].format[format] )
738 continue;
739
740 formatEntry = glyphsetCache[entry].format[format];
741
742 if(formatEntry->glyphset) {
743 wine_tsx11_lock();
744 pXRenderFreeGlyphSet(gdi_display, formatEntry->glyphset);
745 wine_tsx11_unlock();
746 formatEntry->glyphset = 0;
747 }
748 if(formatEntry->nrealized) {
749 HeapFree(GetProcessHeap(), 0, formatEntry->realized);
750 formatEntry->realized = NULL;
751 if(formatEntry->bitmaps) {
752 for(i = 0; i < formatEntry->nrealized; i++)
753 HeapFree(GetProcessHeap(), 0, formatEntry->bitmaps[i]);
754 HeapFree(GetProcessHeap(), 0, formatEntry->bitmaps);
755 formatEntry->bitmaps = NULL;
756 }
757 HeapFree(GetProcessHeap(), 0, formatEntry->gis);
758 formatEntry->gis = NULL;
759 formatEntry->nrealized = 0;
760 }
761
762 HeapFree(GetProcessHeap(), 0, formatEntry);
763 glyphsetCache[entry].format[format] = NULL;
764 }
765 }
766
767 static int AllocEntry(void)
768 {
769 int best = -1, prev_best = -1, i, prev_i = -1;
770
771 if(lastfree >= 0) {
772 assert(glyphsetCache[lastfree].count == -1);
773 glyphsetCache[lastfree].count = 1;
774 best = lastfree;
775 lastfree = glyphsetCache[lastfree].next;
776 assert(best != mru);
777 glyphsetCache[best].next = mru;
778 mru = best;
779
780 TRACE("empty space at %d, next lastfree = %d\n", mru, lastfree);
781 return mru;
782 }
783
784 for(i = mru; i >= 0; i = glyphsetCache[i].next) {
785 if(glyphsetCache[i].count == 0) {
786 best = i;
787 prev_best = prev_i;
788 }
789 prev_i = i;
790 }
791
792 if(best >= 0) {
793 TRACE("freeing unused glyphset at cache %d\n", best);
794 FreeEntry(best);
795 glyphsetCache[best].count = 1;
796 if(prev_best >= 0) {
797 glyphsetCache[prev_best].next = glyphsetCache[best].next;
798 glyphsetCache[best].next = mru;
799 mru = best;
800 } else {
801 assert(mru == best);
802 }
803 return mru;
804 }
805
806 TRACE("Growing cache\n");
807
808 if (glyphsetCache)
809 glyphsetCache = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
810 glyphsetCache,
811 (glyphsetCacheSize + INIT_CACHE_SIZE)
812 * sizeof(*glyphsetCache));
813 else
814 glyphsetCache = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
815 (glyphsetCacheSize + INIT_CACHE_SIZE)
816 * sizeof(*glyphsetCache));
817
818 for(best = i = glyphsetCacheSize; i < glyphsetCacheSize + INIT_CACHE_SIZE;
819 i++) {
820 glyphsetCache[i].next = i + 1;
821 glyphsetCache[i].count = -1;
822 }
823 glyphsetCache[i-1].next = -1;
824 glyphsetCacheSize += INIT_CACHE_SIZE;
825
826 lastfree = glyphsetCache[best].next;
827 glyphsetCache[best].count = 1;
828 glyphsetCache[best].next = mru;
829 mru = best;
830 TRACE("new free cache slot at %d\n", mru);
831 return mru;
832 }
833
834 static BOOL get_gasp_flags(HDC hdc, WORD *flags)
835 {
836 DWORD size;
837 WORD *gasp, *buffer;
838 WORD num_recs;
839 DWORD ppem;
840 TEXTMETRICW tm;
841
842 *flags = 0;
843
844 size = GetFontData(hdc, MS_GASP_TAG, 0, NULL, 0);
845 if(size == GDI_ERROR)
846 return FALSE;
847
848 gasp = buffer = HeapAlloc(GetProcessHeap(), 0, size);
849 GetFontData(hdc, MS_GASP_TAG, 0, gasp, size);
850
851 GetTextMetricsW(hdc, &tm);
852 ppem = abs(X11DRV_YWStoDS(hdc, tm.tmAscent + tm.tmDescent - tm.tmInternalLeading));
853
854 gasp++;
855 num_recs = get_be_word(*gasp);
856 gasp++;
857 while(num_recs--)
858 {
859 *flags = get_be_word(*(gasp + 1));
860 if(ppem <= get_be_word(*gasp))
861 break;
862 gasp += 2;
863 }
864 TRACE("got flags %04x for ppem %d\n", *flags, ppem);
865
866 HeapFree(GetProcessHeap(), 0, buffer);
867 return TRUE;
868 }
869
870 static AA_Type get_antialias_type( HDC hdc, BOOL subpixel, BOOL hinter )
871 {
872 AA_Type ret;
873 WORD flags;
874 UINT font_smoothing_type, font_smoothing_orientation;
875
876 if (X11DRV_XRender_Installed && subpixel &&
877 SystemParametersInfoW( SPI_GETFONTSMOOTHINGTYPE, 0, &font_smoothing_type, 0) &&
878 font_smoothing_type == FE_FONTSMOOTHINGCLEARTYPE)
879 {
880 if ( SystemParametersInfoW( SPI_GETFONTSMOOTHINGORIENTATION, 0,
881 &font_smoothing_orientation, 0) &&
882 font_smoothing_orientation == FE_FONTSMOOTHINGORIENTATIONBGR)
883 {
884 ret = AA_BGR;
885 }
886 else
887 ret = AA_RGB;
888 /*FIXME
889 If the monitor is in portrait mode, ClearType is disabled in the MS Windows (MSDN).
890 But, Wine's subpixel rendering can support the portrait mode.
891 */
892 }
893 else if (!hinter || !get_gasp_flags(hdc, &flags) || flags & GASP_DOGRAY)
894 ret = AA_Grey;
895 else
896 ret = AA_None;
897
898 return ret;
899 }
900
901 static int GetCacheEntry( HDC hdc, LFANDSIZE *plfsz )
902 {
903 int ret;
904 int format;
905 gsCacheEntry *entry;
906 static int hinter = -1;
907 static int subpixel = -1;
908 BOOL font_smoothing;
909
910 if((ret = LookupEntry(plfsz)) != -1) return ret;
911
912 ret = AllocEntry();
913 entry = glyphsetCache + ret;
914 entry->lfsz = *plfsz;
915 for( format = 0; format < AA_MAXVALUE; format++ ) {
916 assert( !entry->format[format] );
917 }
918
919 if(antialias && plfsz->lf.lfQuality != NONANTIALIASED_QUALITY)
920 {
921 if(hinter == -1 || subpixel == -1)
922 {
923 RASTERIZER_STATUS status;
924 GetRasterizerCaps(&status, sizeof(status));
925 hinter = status.wFlags & WINE_TT_HINTER_ENABLED;
926 subpixel = status.wFlags & WINE_TT_SUBPIXEL_RENDERING_ENABLED;
927 }
928
929 switch (plfsz->lf.lfQuality)
930 {
931 case ANTIALIASED_QUALITY:
932 entry->aa_default = get_antialias_type( hdc, FALSE, hinter );
933 return ret; /* ignore further configuration */
934 case CLEARTYPE_QUALITY:
935 case CLEARTYPE_NATURAL_QUALITY:
936 entry->aa_default = get_antialias_type( hdc, subpixel, hinter );
937 break;
938 case DEFAULT_QUALITY:
939 case DRAFT_QUALITY:
940 case PROOF_QUALITY:
941 default:
942 if ( SystemParametersInfoW( SPI_GETFONTSMOOTHING, 0, &font_smoothing, 0) &&
943 font_smoothing)
944 {
945 entry->aa_default = get_antialias_type( hdc, subpixel, hinter );
946 }
947 else
948 entry->aa_default = AA_None;
949 break;
950 }
951
952 font_smoothing = TRUE; /* default to enabled */
953 #ifdef SONAME_LIBFONTCONFIG
954 if (fontconfig_installed)
955 {
956 FcPattern *match, *pattern = pFcPatternCreate();
957 FcResult result;
958 char family[LF_FACESIZE * 4];
959
960 WideCharToMultiByte( CP_UTF8, 0, plfsz->lf.lfFaceName, -1, family, sizeof(family), NULL, NULL );
961 pFcPatternAddString( pattern, FC_FAMILY, (FcChar8 *)family );
962 if (plfsz->lf.lfWeight != FW_DONTCARE)
963 {
964 int weight;
965 switch (plfsz->lf.lfWeight)
966 {
967 case FW_THIN: weight = FC_WEIGHT_THIN; break;
968 case FW_EXTRALIGHT: weight = FC_WEIGHT_EXTRALIGHT; break;
969 case FW_LIGHT: weight = FC_WEIGHT_LIGHT; break;
970 case FW_NORMAL: weight = FC_WEIGHT_NORMAL; break;
971 case FW_MEDIUM: weight = FC_WEIGHT_MEDIUM; break;
972 case FW_SEMIBOLD: weight = FC_WEIGHT_SEMIBOLD; break;
973 case FW_BOLD: weight = FC_WEIGHT_BOLD; break;
974 case FW_EXTRABOLD: weight = FC_WEIGHT_EXTRABOLD; break;
975 case FW_HEAVY: weight = FC_WEIGHT_HEAVY; break;
976 default: weight = (plfsz->lf.lfWeight - 80) / 4; break;
977 }
978 pFcPatternAddInteger( pattern, FC_WEIGHT, weight );
979 }
980 pFcPatternAddInteger( pattern, FC_SLANT, plfsz->lf.lfItalic ? FC_SLANT_ITALIC : FC_SLANT_ROMAN );
981 pFcConfigSubstitute( NULL, pattern, FcMatchPattern );
982 pFcDefaultSubstitute( pattern );
983 if ((match = pFcFontMatch( NULL, pattern, &result )))
984 {
985 int rgba;
986 FcBool antialias;
987
988 if (pFcPatternGetBool( match, FC_ANTIALIAS, 0, &antialias ) != FcResultMatch)
989 antialias = TRUE;
990 if (pFcPatternGetInteger( match, FC_RGBA, 0, &rgba ) == FcResultMatch)
991 {
992 FcChar8 *file;
993 if (pFcPatternGetString( match, FC_FILE, 0, &file ) != FcResultMatch) file = NULL;
994
995 TRACE( "fontconfig returned rgba %u antialias %u for font %s file %s\n",
996 rgba, antialias, debugstr_w(plfsz->lf.lfFaceName), debugstr_a((char *)file) );
997
998 switch (rgba)
999 {
1000 case FC_RGBA_RGB: entry->aa_default = AA_RGB; break;
1001 case FC_RGBA_BGR: entry->aa_default = AA_BGR; break;
1002 case FC_RGBA_VRGB: entry->aa_default = AA_VRGB; break;
1003 case FC_RGBA_VBGR: entry->aa_default = AA_VBGR; break;
1004 case FC_RGBA_NONE: entry->aa_default = AA_Grey; break;
1005 }
1006 }
1007 if (!antialias) font_smoothing = FALSE;
1008 pFcPatternDestroy( match );
1009 }
1010 pFcPatternDestroy( pattern );
1011 }
1012 #endif /* SONAME_LIBFONTCONFIG */
1013
1014 /* now check Xft resources */
1015 {
1016 char *value;
1017 BOOL antialias = TRUE;
1018
1019 wine_tsx11_lock();
1020 if ((value = XGetDefault( gdi_display, "Xft", "antialias" )))
1021 {
1022 if (tolower(value[0]) == 'f' || tolower(value[0]) == 'n' ||
1023 value[0] == '0' || !strcasecmp( value, "off" ))
1024 antialias = FALSE;
1025 }
1026 if ((value = XGetDefault( gdi_display, "Xft", "rgba" )))
1027 {
1028 TRACE( "Xft resource returned rgba '%s' antialias %u\n", value, antialias );
1029 if (!strcmp( value, "rgb" )) entry->aa_default = AA_RGB;
1030 else if (!strcmp( value, "bgr" )) entry->aa_default = AA_BGR;
1031 else if (!strcmp( value, "vrgb" )) entry->aa_default = AA_VRGB;
1032 else if (!strcmp( value, "vbgr" )) entry->aa_default = AA_VBGR;
1033 else if (!strcmp( value, "none" )) entry->aa_default = AA_Grey;
1034 }
1035 wine_tsx11_unlock();
1036 if (!antialias) font_smoothing = FALSE;
1037 }
1038
1039 if (!font_smoothing) entry->aa_default = AA_None;
1040
1041 /* we can't support subpixel without xrender */
1042 if (!X11DRV_XRender_Installed && entry->aa_default > AA_Grey) entry->aa_default = AA_Grey;
1043 }
1044 else
1045 entry->aa_default = AA_None;
1046
1047 return ret;
1048 }
1049
1050 static void dec_ref_cache(int index)
1051 {
1052 assert(index >= 0);
1053 TRACE("dec'ing entry %d to %d\n", index, glyphsetCache[index].count - 1);
1054 assert(glyphsetCache[index].count > 0);
1055 glyphsetCache[index].count--;
1056 }
1057
1058 static void lfsz_calc_hash(LFANDSIZE *plfsz)
1059 {
1060 DWORD hash = 0, *ptr, two_chars;
1061 WORD *pwc;
1062 int i;
1063
1064 hash ^= plfsz->devsize.cx;
1065 hash ^= plfsz->devsize.cy;
1066 for(i = 0, ptr = (DWORD*)&plfsz->xform; i < sizeof(XFORM)/sizeof(DWORD); i++, ptr++)
1067 hash ^= *ptr;
1068 for(i = 0, ptr = (DWORD*)&plfsz->lf; i < 7; i++, ptr++)
1069 hash ^= *ptr;
1070 for(i = 0, ptr = (DWORD*)plfsz->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) {
1071 two_chars = *ptr;
1072 pwc = (WCHAR *)&two_chars;
1073 if(!*pwc) break;
1074 *pwc = toupperW(*pwc);
1075 pwc++;
1076 *pwc = toupperW(*pwc);
1077 hash ^= two_chars;
1078 if(!*pwc) break;
1079 }
1080 plfsz->hash = hash;
1081 return;
1082 }
1083
1084 /***********************************************************************
1085 * X11DRV_XRender_Finalize
1086 */
1087 void X11DRV_XRender_Finalize(void)
1088 {
1089 int i;
1090
1091 EnterCriticalSection(&xrender_cs);
1092 for(i = mru; i >= 0; i = glyphsetCache[i].next)
1093 FreeEntry(i);
1094 LeaveCriticalSection(&xrender_cs);
1095 }
1096
1097 /**********************************************************************
1098 * xrenderdrv_SelectFont
1099 */
1100 static HFONT xrenderdrv_SelectFont( PHYSDEV dev, HFONT hfont, HANDLE gdiFont )
1101 {
1102 struct xrender_physdev *physdev = get_xrender_dev( dev );
1103 LFANDSIZE lfsz;
1104
1105 if (!GetObjectW( hfont, sizeof(lfsz.lf), &lfsz.lf )) return HGDI_ERROR;
1106
1107 if (!gdiFont)
1108 {
1109 dev = GET_NEXT_PHYSDEV( dev, pSelectFont );
1110 return dev->funcs->pSelectFont( dev, hfont, gdiFont );
1111 }
1112
1113 TRACE("h=%d w=%d weight=%d it=%d charset=%d name=%s\n",
1114 lfsz.lf.lfHeight, lfsz.lf.lfWidth, lfsz.lf.lfWeight,
1115 lfsz.lf.lfItalic, lfsz.lf.lfCharSet, debugstr_w(lfsz.lf.lfFaceName));
1116 lfsz.lf.lfWidth = abs( lfsz.lf.lfWidth );
1117 lfsz.devsize.cx = X11DRV_XWStoDS( dev->hdc, lfsz.lf.lfWidth );
1118 lfsz.devsize.cy = X11DRV_YWStoDS( dev->hdc, lfsz.lf.lfHeight );
1119
1120 GetTransform( dev->hdc, 0x204, &lfsz.xform );
1121 TRACE("font transform %f %f %f %f\n", lfsz.xform.eM11, lfsz.xform.eM12,
1122 lfsz.xform.eM21, lfsz.xform.eM22);
1123
1124 /* Not used fields, would break hashing */
1125 lfsz.xform.eDx = lfsz.xform.eDy = 0;
1126
1127 lfsz_calc_hash(&lfsz);
1128
1129 EnterCriticalSection(&xrender_cs);
1130 if (physdev->cache_index != -1)
1131 dec_ref_cache( physdev->cache_index );
1132 physdev->cache_index = GetCacheEntry( dev->hdc, &lfsz );
1133 LeaveCriticalSection(&xrender_cs);
1134 physdev->x11dev->has_gdi_font = TRUE;
1135 return 0;
1136 }
1137
1138 static BOOL create_xrender_dc( PHYSDEV *pdev, enum wxr_format format )
1139 {
1140 X11DRV_PDEVICE *x11dev = get_x11drv_dev( *pdev );
1141 struct xrender_physdev *physdev = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*physdev) );
1142
1143 if (!physdev) return FALSE;
1144 physdev->x11dev = x11dev;
1145 physdev->cache_index = -1;
1146 physdev->format = format;
1147 physdev->pict_format = pict_formats[format];
1148 push_dc_driver( pdev, &physdev->dev, &xrender_funcs );
1149 return TRUE;
1150 }
1151
1152 /* store the color mask data in the bitmap info structure */
1153 static void set_color_info( XRenderPictFormat *format, BITMAPINFO *info )
1154 {
1155 DWORD *colors = (DWORD *)((char *)info + info->bmiHeader.biSize);
1156
1157 info->bmiHeader.biPlanes = 1;
1158 info->bmiHeader.biBitCount = pixmap_formats[format->depth]->bits_per_pixel;
1159 info->bmiHeader.biCompression = BI_RGB;
1160 info->bmiHeader.biClrUsed = 0;
1161
1162 switch (info->bmiHeader.biBitCount)
1163 {
1164 case 16:
1165 colors[0] = format->direct.redMask << format->direct.red;
1166 colors[1] = format->direct.greenMask << format->direct.green;
1167 colors[2] = format->direct.blueMask << format->direct.blue;
1168 info->bmiHeader.biCompression = BI_BITFIELDS;
1169 break;
1170 case 32:
1171 colors[0] = format->direct.redMask << format->direct.red;
1172 colors[1] = format->direct.greenMask << format->direct.green;
1173 colors[2] = format->direct.blueMask << format->direct.blue;
1174 if (colors[0] != 0xff0000 || colors[1] != 0x00ff00 || colors[2] != 0x0000ff)
1175 info->bmiHeader.biCompression = BI_BITFIELDS;
1176 break;
1177 }
1178 }
1179
1180
1181 /**********************************************************************
1182 * xrenderdrv_CreateDC
1183 */
1184 static BOOL xrenderdrv_CreateDC( PHYSDEV *pdev, LPCWSTR driver, LPCWSTR device,
1185 LPCWSTR output, const DEVMODEW* initData )
1186 {
1187 return create_xrender_dc( pdev, default_format );
1188 }
1189
1190 /**********************************************************************
1191 * xrenderdrv_CreateCompatibleDC
1192 */
1193 static BOOL xrenderdrv_CreateCompatibleDC( PHYSDEV orig, PHYSDEV *pdev )
1194 {
1195 if (orig) /* chain to x11drv first */
1196 {
1197 orig = GET_NEXT_PHYSDEV( orig, pCreateCompatibleDC );
1198 if (!orig->funcs->pCreateCompatibleDC( orig, pdev )) return FALSE;
1199 }
1200 /* otherwise we have been called by x11drv */
1201
1202 return create_xrender_dc( pdev, WXR_FORMAT_MONO );
1203 }
1204
1205 /**********************************************************************
1206 * xrenderdrv_DeleteDC
1207 */
1208 static BOOL xrenderdrv_DeleteDC( PHYSDEV dev )
1209 {
1210 struct xrender_physdev *physdev = get_xrender_dev( dev );
1211
1212 free_xrender_picture( physdev );
1213
1214 EnterCriticalSection( &xrender_cs );
1215 if (physdev->cache_index != -1) dec_ref_cache( physdev->cache_index );
1216 LeaveCriticalSection( &xrender_cs );
1217
1218 HeapFree( GetProcessHeap(), 0, physdev );
1219 return TRUE;
1220 }
1221
1222 /**********************************************************************
1223 * xrenderdrv_ExtEscape
1224 */
1225 static INT xrenderdrv_ExtEscape( PHYSDEV dev, INT escape, INT in_count, LPCVOID in_data,
1226 INT out_count, LPVOID out_data )
1227 {
1228 struct xrender_physdev *physdev = get_xrender_dev( dev );
1229
1230 dev = GET_NEXT_PHYSDEV( dev, pExtEscape );
1231
1232 if (escape == X11DRV_ESCAPE && in_data && in_count >= sizeof(enum x11drv_escape_codes))
1233 {
1234 if (*(const enum x11drv_escape_codes *)in_data == X11DRV_SET_DRAWABLE)
1235 {
1236 BOOL ret = dev->funcs->pExtEscape( dev, escape, in_count, in_data, out_count, out_data );
1237 if (ret) free_xrender_picture( physdev ); /* pict format doesn't change, only drawable */
1238 return ret;
1239 }
1240 }
1241 return dev->funcs->pExtEscape( dev, escape, in_count, in_data, out_count, out_data );
1242 }
1243
1244 /****************************************************************************
1245 * xrenderdrv_CreateBitmap
1246 */
1247 static BOOL xrenderdrv_CreateBitmap( PHYSDEV dev, HBITMAP hbitmap )
1248 {
1249 enum wxr_format format = WXR_INVALID_FORMAT;
1250 BITMAP bitmap;
1251
1252 if (!GetObjectW( hbitmap, sizeof(bitmap), &bitmap )) return FALSE;
1253
1254 if (bitmap.bmPlanes == 1 && bitmap.bmBitsPixel == screen_bpp)
1255 {
1256 switch (bitmap.bmBitsPixel)
1257 {
1258 case 16: format = WXR_FORMAT_R5G6B5; break;
1259 case 24: format = WXR_FORMAT_R8G8B8; break;
1260 case 32: format = WXR_FORMAT_A8R8G8B8; break;
1261 }
1262 }
1263
1264 if (pict_formats[format])
1265 return X11DRV_create_phys_bitmap( hbitmap, &bitmap, pict_formats[format]->depth,
1266 TRUE, &wxr_color_shifts[format] );
1267
1268 dev = GET_NEXT_PHYSDEV( dev, pCreateBitmap );
1269 return dev->funcs->pCreateBitmap( dev, hbitmap );
1270 }
1271
1272 /****************************************************************************
1273 * xrenderdrv_DeleteBitmap
1274 */
1275 static BOOL xrenderdrv_DeleteBitmap( HBITMAP hbitmap )
1276 {
1277 return X11DRV_DeleteBitmap( hbitmap );
1278 }
1279
1280 /***********************************************************************
1281 * xrenderdrv_SelectBitmap
1282 */
1283 static HBITMAP xrenderdrv_SelectBitmap( PHYSDEV dev, HBITMAP hbitmap )
1284 {
1285 HBITMAP ret;
1286 struct xrender_physdev *physdev = get_xrender_dev( dev );
1287
1288 dev = GET_NEXT_PHYSDEV( dev, pSelectBitmap );
1289 ret = dev->funcs->pSelectBitmap( dev, hbitmap );
1290 if (ret)
1291 {
1292 free_xrender_picture( physdev );
1293 physdev->format = get_xrender_format_from_color_shifts( physdev->x11dev->depth,
1294 physdev->x11dev->color_shifts );
1295 physdev->pict_format = pict_formats[physdev->format];
1296 }
1297 return ret;
1298 }
1299
1300 /***********************************************************************
1301 * xrenderdrv_GetImage
1302 */
1303 static DWORD xrenderdrv_GetImage( PHYSDEV dev, HBITMAP hbitmap, BITMAPINFO *info,
1304 struct gdi_image_bits *bits, struct bitblt_coords *src )
1305 {
1306 if (hbitmap) return X11DRV_GetImage( dev, hbitmap, info, bits, src );
1307 dev = GET_NEXT_PHYSDEV( dev, pGetImage );
1308 return dev->funcs->pGetImage( dev, hbitmap, info, bits, src );
1309 }
1310
1311 /***********************************************************************
1312 * xrenderdrv_SetDeviceClipping
1313 */
1314 static void xrenderdrv_SetDeviceClipping( PHYSDEV dev, HRGN vis_rgn, HRGN clip_rgn )
1315 {
1316 struct xrender_physdev *physdev = get_xrender_dev( dev );
1317
1318 physdev->update_clip = TRUE;
1319
1320 dev = GET_NEXT_PHYSDEV( dev, pSetDeviceClipping );
1321 dev->funcs->pSetDeviceClipping( dev, vis_rgn, clip_rgn );
1322 }
1323
1324
1325 BOOL X11DRV_XRender_SetPhysBitmapDepth(X_PHYSBITMAP *physBitmap, int bits_pixel, const DIBSECTION *dib)
1326 {
1327 XRenderPictFormat *pict_format;
1328 ColorShifts shifts;
1329 const DWORD *bitfields;
1330 static const DWORD bitfields_32[3] = {0xff0000, 0x00ff00, 0x0000ff};
1331 static const DWORD bitfields_16[3] = {0x7c00, 0x03e0, 0x001f};
1332
1333
1334 /* When XRender is not around we can only use the screen_depth and when needed we perform depth conversion
1335 * in software. Further we also return the screen depth for paletted formats or TrueColor formats with a low
1336 * number of bits because XRender can't handle paletted formats and 8-bit TrueColor does not exist for XRender. */
1337 if (!X11DRV_XRender_Installed || bits_pixel <= 8)
1338 return FALSE;
1339
1340 if(dib->dsBmih.biCompression == BI_BITFIELDS)
1341 bitfields = dib->dsBitfields;
1342 else if(bits_pixel == 24 || bits_pixel == 32)
1343 bitfields = bitfields_32;
1344 else
1345 bitfields = bitfields_16;
1346
1347 X11DRV_PALETTE_ComputeColorShifts(&shifts, bitfields[0], bitfields[1], bitfields[2]);
1348 pict_format = pict_formats[get_xrender_format_from_color_shifts(dib->dsBm.bmBitsPixel, &shifts)];
1349
1350 /* Common formats should be in our picture format table. */
1351 if (!pict_format)
1352 {
1353 TRACE("Unhandled dibsection format bpp=%d, redMask=%x, greenMask=%x, blueMask=%x\n",
1354 dib->dsBm.bmBitsPixel, bitfields[0], bitfields[1], bitfields[2]);
1355 return FALSE;
1356 }
1357
1358 physBitmap->depth = pict_format->depth;
1359 physBitmap->trueColor = TRUE;
1360 physBitmap->color_shifts = shifts;
1361 return TRUE;
1362 }
1363
1364 /************************************************************************
1365 * UploadGlyph
1366 *
1367 * Helper to ExtTextOut. Must be called inside xrender_cs
1368 */
1369 static void UploadGlyph(struct xrender_physdev *physDev, int glyph, AA_Type format)
1370 {
1371 unsigned int buflen;
1372 char *buf;
1373 Glyph gid;
1374 GLYPHMETRICS gm;
1375 XGlyphInfo gi;
1376 gsCacheEntry *entry = glyphsetCache + physDev->cache_index;
1377 gsCacheEntryFormat *formatEntry;
1378 UINT ggo_format = GGO_GLYPH_INDEX;
1379 enum wxr_format wxr_format;
1380 static const char zero[4];
1381 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
1382
1383 switch(format) {
1384 case AA_Grey:
1385 ggo_format |= WINE_GGO_GRAY16_BITMAP;
1386 break;
1387 case AA_RGB:
1388 ggo_format |= WINE_GGO_HRGB_BITMAP;
1389 break;
1390 case AA_BGR:
1391 ggo_format |= WINE_GGO_HBGR_BITMAP;
1392 break;
1393 case AA_VRGB:
1394 ggo_format |= WINE_GGO_VRGB_BITMAP;
1395 break;
1396 case AA_VBGR:
1397 ggo_format |= WINE_GGO_VBGR_BITMAP;
1398 break;
1399
1400 default:
1401 ERR("aa = %d - not implemented\n", format);
1402 case AA_None:
1403 ggo_format |= GGO_BITMAP;
1404 break;
1405 }
1406
1407 buflen = GetGlyphOutlineW(physDev->dev.hdc, glyph, ggo_format, &gm, 0, NULL, &identity);
1408 if(buflen == GDI_ERROR) {
1409 if(format != AA_None) {
1410 format = AA_None;
1411 entry->aa_default = AA_None;
1412 ggo_format = GGO_GLYPH_INDEX | GGO_BITMAP;
1413 buflen = GetGlyphOutlineW(physDev->dev.hdc, glyph, ggo_format, &gm, 0, NULL, &identity);
1414 }
1415 if(buflen == GDI_ERROR) {
1416 WARN("GetGlyphOutlineW failed using default glyph\n");
1417 buflen = GetGlyphOutlineW(physDev->dev.hdc, 0, ggo_format, &gm, 0, NULL, &identity);
1418 if(buflen == GDI_ERROR) {
1419 WARN("GetGlyphOutlineW failed for default glyph trying for space\n");
1420 buflen = GetGlyphOutlineW(physDev->dev.hdc, 0x20, ggo_format, &gm, 0, NULL, &identity);
1421 if(buflen == GDI_ERROR) {
1422 ERR("GetGlyphOutlineW for all attempts unable to upload a glyph\n");
1423 return;
1424 }
1425 }
1426 }
1427 TRACE("Turning off antialiasing for this monochrome font\n");
1428 }
1429
1430 /* If there is nothing for the current type, we create the entry. */
1431 if( !entry->format[format] ) {
1432 entry->format[format] = HeapAlloc(GetProcessHeap(),
1433 HEAP_ZERO_MEMORY,
1434 sizeof(gsCacheEntryFormat));
1435 }
1436 formatEntry = entry->format[format];
1437
1438 if(formatEntry->nrealized <= glyph) {
1439 formatEntry->nrealized = (glyph / 128 + 1) * 128;
1440
1441 if (formatEntry->realized)
1442 formatEntry->realized = HeapReAlloc(GetProcessHeap(),
1443 HEAP_ZERO_MEMORY,
1444 formatEntry->realized,
1445 formatEntry->nrealized * sizeof(BOOL));
1446 else
1447 formatEntry->realized = HeapAlloc(GetProcessHeap(),
1448 HEAP_ZERO_MEMORY,
1449 formatEntry->nrealized * sizeof(BOOL));
1450
1451 if(!X11DRV_XRender_Installed) {
1452 if (formatEntry->bitmaps)
1453 formatEntry->bitmaps = HeapReAlloc(GetProcessHeap(),
1454 HEAP_ZERO_MEMORY,
1455 formatEntry->bitmaps,
1456 formatEntry->nrealized * sizeof(formatEntry->bitmaps[0]));
1457 else
1458 formatEntry->bitmaps = HeapAlloc(GetProcessHeap(),
1459 HEAP_ZERO_MEMORY,
1460 formatEntry->nrealized * sizeof(formatEntry->bitmaps[0]));
1461 }
1462 if (formatEntry->gis)
1463 formatEntry->gis = HeapReAlloc(GetProcessHeap(),
1464 HEAP_ZERO_MEMORY,
1465 formatEntry->gis,
1466 formatEntry->nrealized * sizeof(formatEntry->gis[0]));
1467 else
1468 formatEntry->gis = HeapAlloc(GetProcessHeap(),
1469 HEAP_ZERO_MEMORY,
1470 formatEntry->nrealized * sizeof(formatEntry->gis[0]));
1471 }
1472
1473
1474 if(formatEntry->glyphset == 0 && X11DRV_XRender_Installed) {
1475 switch(format) {
1476 case AA_Grey:
1477 wxr_format = WXR_FORMAT_GRAY;
1478 break;
1479
1480 case AA_RGB:
1481 case AA_BGR:
1482 case AA_VRGB:
1483 case AA_VBGR:
1484 wxr_format = WXR_FORMAT_A8R8G8B8;
1485 break;
1486
1487 default:
1488 ERR("aa = %d - not implemented\n", format);
1489 case AA_None:
1490 wxr_format = WXR_FORMAT_MONO;
1491 break;
1492 }
1493
1494 wine_tsx11_lock();
1495 formatEntry->font_format = pict_formats[wxr_format];
1496 formatEntry->glyphset = pXRenderCreateGlyphSet(gdi_display, formatEntry->font_format);
1497 wine_tsx11_unlock();
1498 }
1499
1500
1501 buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buflen);
1502 GetGlyphOutlineW(physDev->dev.hdc, glyph, ggo_format, &gm, buflen, buf, &identity);
1503 formatEntry->realized[glyph] = TRUE;
1504
1505 TRACE("buflen = %d. Got metrics: %dx%d adv=%d,%d origin=%d,%d\n",
1506 buflen,
1507 gm.gmBlackBoxX, gm.gmBlackBoxY, gm.gmCellIncX, gm.gmCellIncY,
1508 gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
1509
1510 gi.width = gm.gmBlackBoxX;
1511 gi.height = gm.gmBlackBoxY;
1512 gi.x = -gm.gmptGlyphOrigin.x;
1513 gi.y = gm.gmptGlyphOrigin.y;
1514 gi.xOff = gm.gmCellIncX;
1515 gi.yOff = gm.gmCellIncY;
1516
1517 if(TRACE_ON(xrender)) {
1518 int pitch, i, j;
1519 char output[300];
1520 unsigned char *line;
1521
1522 if(format == AA_None) {
1523 pitch = ((gi.width + 31) / 32) * 4;
1524 for(i = 0; i < gi.height; i++) {
1525 line = (unsigned char*) buf + i * pitch;
1526 output[0] = '\0';
1527 for(j = 0; j < pitch * 8; j++) {
1528 strcat(output, (line[j / 8] & (1 << (7 - (j % 8)))) ? "#" : " ");
1529 }
1530 TRACE("%s\n", output);
1531 }
1532 } else {
1533 static const char blks[] = " .:;!o*#";
1534 char str[2];
1535
1536 str[1] = '\0';
1537 pitch = ((gi.width + 3) / 4) * 4;
1538 for(i = 0; i < gi.height; i++) {
1539 line = (unsigned char*) buf + i * pitch;
1540 output[0] = '\0';
1541 for(j = 0; j < pitch; j++) {
1542 str[0] = blks[line[j] >> 5];
1543 strcat(output, str);
1544 }
1545 TRACE("%s\n", output);
1546 }
1547 }
1548 }
1549
1550
1551 if(formatEntry->glyphset) {
1552 if(format == AA_None && BitmapBitOrder(gdi_display) != MSBFirst) {
1553 unsigned char *byte = (unsigned char*) buf, c;
1554 int i = buflen;
1555
1556 while(i--) {
1557 c = *byte;
1558
1559 /* magic to flip bit order */
1560 c = ((c << 1) & 0xaa) | ((c >> 1) & 0x55);
1561 c = ((c << 2) & 0xcc) | ((c >> 2) & 0x33);
1562 c = ((c << 4) & 0xf0) | ((c >> 4) & 0x0f);
1563
1564 *byte++ = c;
1565 }
1566 }
1567 else if ( format != AA_Grey &&
1568 ImageByteOrder (gdi_display) != NATIVE_BYTE_ORDER)
1569 {
1570 unsigned int i, *data = (unsigned int *)buf;
1571 for (i = buflen / sizeof(int); i; i--, data++) *data = RtlUlongByteSwap(*data);
1572 }
1573 gid = glyph;
1574
1575 /*
1576 XRenderCompositeText seems to ignore 0x0 glyphs when
1577 AA_None, which means we lose the advance width of glyphs
1578 like the space. We'll pretend that such glyphs are 1x1
1579 bitmaps.
1580 */
1581
1582 if(buflen == 0)
1583 gi.width = gi.height = 1;
1584
1585 wine_tsx11_lock();
1586 pXRenderAddGlyphs(gdi_display, formatEntry->glyphset, &gid, &gi, 1,
1587 buflen ? buf : zero, buflen ? buflen : sizeof(zero));
1588 wine_tsx11_unlock();
1589 HeapFree(GetProcessHeap(), 0, buf);
1590 } else {
1591 formatEntry->bitmaps[glyph] = buf;
1592 }
1593
1594 formatEntry->gis[glyph] = gi;
1595 }
1596
1597 static void SharpGlyphMono(struct xrender_physdev *physDev, INT x, INT y,
1598 void *bitmap, XGlyphInfo *gi)
1599 {
1600 unsigned char *srcLine = bitmap, *src;
1601 unsigned char bits, bitsMask;
1602 int width = gi->width;
1603 int stride = ((width + 31) & ~31) >> 3;
1604 int height = gi->height;
1605 int w;
1606 int xspan, lenspan;
1607
1608 TRACE("%d, %d\n", x, y);
1609 x -= gi->x;
1610 y -= gi->y;
1611 while (height--)
1612 {
1613 src = srcLine;
1614 srcLine += stride;
1615 w = width;
1616
1617 bitsMask = 0x80; /* FreeType is always MSB first */
1618 bits = *src++;
1619
1620 xspan = x;
1621 while (w)
1622 {
1623 if (bits & bitsMask)
1624 {
1625 lenspan = 0;
1626 do
1627 {
1628 lenspan++;
1629 if (lenspan == w)
1630 break;
1631 bitsMask = bitsMask >> 1;
1632 if (!bitsMask)
1633 {
1634 bits = *src++;
1635 bitsMask = 0x80;
1636 }
1637 } while (bits & bitsMask);
1638 XFillRectangle (gdi_display, physDev->x11dev->drawable,
1639 physDev->x11dev->gc, xspan, y, lenspan, 1);
1640 xspan += lenspan;
1641 w -= lenspan;
1642 }
1643 else
1644 {
1645 do
1646 {
1647 w--;
1648 xspan++;
1649 if (!w)
1650 break;
1651 bitsMask = bitsMask >> 1;
1652 if (!bitsMask)
1653 {
1654 bits = *src++;
1655 bitsMask = 0x80;
1656 }
1657 } while (!(bits & bitsMask));
1658 }
1659 }
1660 y++;
1661 }
1662 }
1663
1664 static void SharpGlyphGray(struct xrender_physdev *physDev, INT x, INT y,
1665 void *bitmap, XGlyphInfo *gi)
1666 {
1667 unsigned char *srcLine = bitmap, *src, bits;
1668 int width = gi->width;
1669 int stride = ((width + 3) & ~3);
1670 int height = gi->height;
1671 int w;
1672 int xspan, lenspan;
1673
1674 x -= gi->x;
1675 y -= gi->y;
1676 while (height--)
1677 {
1678 src = srcLine;
1679 srcLine += stride;
1680 w = width;
1681
1682 bits = *src++;
1683 xspan = x;
1684 while (w)
1685 {
1686 if (bits >= 0x80)
1687 {
1688 lenspan = 0;
1689 do
1690 {
1691 lenspan++;
1692 if (lenspan == w)
1693 break;
1694 bits = *src++;
1695 } while (bits >= 0x80);
1696 XFillRectangle (gdi_display, physDev->x11dev->drawable,
1697 physDev->x11dev->gc, xspan, y, lenspan, 1);
1698 xspan += lenspan;
1699 w -= lenspan;
1700 }
1701 else
1702 {
1703 do
1704 {
1705 w--;
1706 xspan++;
1707 if (!w)
1708 break;
1709 bits = *src++;
1710 } while (bits < 0x80);
1711 }
1712 }
1713 y++;
1714 }
1715 }
1716
1717
1718 static void ExamineBitfield (DWORD mask, int *shift, int *len)
1719 {
1720 int s, l;
1721
1722 s = 0;
1723 while ((mask & 1) == 0)
1724 {
1725 mask >>= 1;
1726 s++;
1727 }
1728 l = 0;
1729 while ((mask & 1) == 1)
1730 {
1731 mask >>= 1;
1732 l++;
1733 }
1734 *shift = s;
1735 *len = l;
1736 }
1737
1738 static DWORD GetField (DWORD pixel, int shift, int len)
1739 {
1740 pixel = pixel & (((1 << (len)) - 1) << shift);
1741 pixel = pixel << (32 - (shift + len)) >> 24;
1742 while (len < 8)
1743 {
1744 pixel |= (pixel >> len);
1745 len <<= 1;
1746 }
1747 return pixel;
1748 }
1749
1750
1751 static DWORD PutField (DWORD pixel, int shift, int len)
1752 {
1753 shift = shift - (8 - len);
1754 if (len <= 8)
1755 pixel &= (((1 << len) - 1) << (8 - len));
1756 if (shift < 0)
1757 pixel >>= -shift;
1758 else
1759 pixel <<= shift;
1760 return pixel;
1761 }
1762
1763 static void SmoothGlyphGray(XImage *image, int x, int y, void *bitmap, XGlyphInfo *gi,
1764 int color)
1765 {
1766 int r_shift, r_len;
1767 int g_shift, g_len;
1768 int b_shift, b_len;
1769 BYTE *maskLine, *mask, m;
1770 int maskStride;
1771 DWORD pixel;
1772 int width, height;
1773 int w, tx;
1774 BYTE src_r, src_g, src_b;
1775
1776 x -= gi->x;
1777 y -= gi->y;
1778 width = gi->width;
1779 height = gi->height;
1780
1781 maskLine = bitmap;
1782 maskStride = (width + 3) & ~3;
1783
1784 ExamineBitfield (image->red_mask, &r_shift, &r_len);
1785 ExamineBitfield (image->green_mask, &g_shift, &g_len);
1786 ExamineBitfield (image->blue_mask, &b_shift, &b_len);
1787
1788 src_r = GetField(color, r_shift, r_len);
1789 src_g = GetField(color, g_shift, g_len);
1790 src_b = GetField(color, b_shift, b_len);
1791
1792 for(; height--; y++)
1793 {
1794 mask = maskLine;
1795 maskLine += maskStride;
1796 w = width;
1797 tx = x;
1798
1799 if(y < 0) continue;
1800 if(y >= image->height) break;
1801
1802 for(; w--; tx++)
1803 {
1804 if(tx >= image->width) break;
1805
1806 m = *mask++;
1807 if(tx < 0) continue;
1808
1809 if (m == 0xff)
1810 XPutPixel (image, tx, y, color);
1811 else if (m)
1812 {
1813 BYTE r, g, b;
1814
1815 pixel = XGetPixel (image, tx, y);
1816
1817 r = GetField(pixel, r_shift, r_len);
1818 r = ((BYTE)~m * (WORD)r + (BYTE)m * (WORD)src_r) >> 8;
1819 g = GetField(pixel, g_shift, g_len);
1820 g = ((BYTE)~m * (WORD)g + (BYTE)m * (WORD)src_g) >> 8;
1821 b = GetField(pixel, b_shift, b_len);
1822 b = ((BYTE)~m * (WORD)b + (BYTE)m * (WORD)src_b) >> 8;
1823
1824 pixel = (PutField (r, r_shift, r_len) |
1825 PutField (g, g_shift, g_len) |
1826 PutField (b, b_shift, b_len));
1827 XPutPixel (image, tx, y, pixel);
1828 }
1829 }
1830 }
1831 }
1832
1833 /*************************************************************
1834 * get_tile_pict
1835 *
1836 * Returns an appropriate Picture for tiling the text colour.
1837 * Call and use result within the xrender_cs
1838 */
1839 static Picture get_tile_pict( enum wxr_format wxr_format, const XRenderColor *color)
1840 {
1841 static struct
1842 {
1843 Pixmap xpm;
1844 Picture pict;
1845 XRenderColor current_color;
1846 } tiles[WXR_NB_FORMATS], *tile;
1847
1848 tile = &tiles[wxr_format];
1849
1850 if(!tile->xpm)
1851 {
1852 XRenderPictureAttributes pa;
1853 XRenderPictFormat *pict_format = pict_formats[wxr_format];
1854
1855 wine_tsx11_lock();
1856 tile->xpm = XCreatePixmap(gdi_display, root_window, 1, 1, pict_format->depth);
1857
1858 pa.repeat = RepeatNormal;
1859 tile->pict = pXRenderCreatePicture(gdi_display, tile->xpm, pict_format, CPRepeat, &pa);
1860 wine_tsx11_unlock();
1861
1862 /* init current_color to something different from text_pixel */
1863 tile->current_color = *color;
1864 tile->current_color.red ^= 0xffff;
1865
1866 if (wxr_format == WXR_FORMAT_MONO)
1867 {
1868 /* for a 1bpp bitmap we always need a 1 in the tile */
1869 XRenderColor col;
1870 col.red = col.green = col.blue = 0;
1871 col.alpha = 0xffff;
1872 wine_tsx11_lock();
1873 pXRenderFillRectangle(gdi_display, PictOpSrc, tile->pict, &col, 0, 0, 1, 1);
1874 wine_tsx11_unlock();
1875 }
1876 }
1877
1878 if (memcmp( color, &tile->current_color, sizeof(*color) ) && wxr_format != WXR_FORMAT_MONO)
1879 {
1880 wine_tsx11_lock();
1881 pXRenderFillRectangle(gdi_display, PictOpSrc, tile->pict, color, 0, 0, 1, 1);
1882 wine_tsx11_unlock();
1883 tile->current_color = *color;
1884 }
1885 return tile->pict;
1886 }
1887
1888 /*************************************************************
1889 * get_mask_pict
1890 *
1891 * Returns an appropriate Picture for masking with the specified alpha.
1892 * Call and use result within the xrender_cs
1893 */
1894 static Picture get_mask_pict( int alpha )
1895 {
1896 static Pixmap pixmap;
1897 static Picture pict;
1898 static int current_alpha;
1899
1900 if (alpha == 0xffff) return 0; /* don't need a mask for alpha==1.0 */
1901
1902 if (!pixmap)
1903 {
1904 XRenderPictureAttributes pa;
1905
1906 wine_tsx11_lock();
1907 pixmap = XCreatePixmap( gdi_display, root_window, 1, 1, 32 );
1908 pa.repeat = RepeatNormal;
1909 pict = pXRenderCreatePicture( gdi_display, pixmap,
1910 pict_formats[WXR_FORMAT_A8R8G8B8], CPRepeat, &pa );
1911 wine_tsx11_unlock();
1912 current_alpha = -1;
1913 }
1914
1915 if (alpha != current_alpha)
1916 {
1917 XRenderColor col;
1918 col.red = col.green = col.blue = 0;
1919 col.alpha = current_alpha = alpha;
1920 wine_tsx11_lock();
1921 pXRenderFillRectangle( gdi_display, PictOpSrc, pict, &col, 0, 0, 1, 1 );
1922 wine_tsx11_unlock();
1923 }
1924 return pict;
1925 }
1926
1927 static int XRenderErrorHandler(Display *dpy, XErrorEvent *event, void *arg)
1928 {
1929 return 1;
1930 }
1931
1932 /********************************************************************
1933 * is_dib_with_colortable
1934 *
1935 * Return TRUE if physdev is backed by a dibsection with <= 8 bits per pixel
1936 */
1937 static inline BOOL is_dib_with_colortable( X11DRV_PDEVICE *physDev )
1938 {
1939 DIBSECTION dib;
1940
1941 if( physDev->bitmap && GetObjectW( physDev->bitmap->hbitmap, sizeof(dib), &dib ) == sizeof(dib) &&
1942 dib.dsBmih.biBitCount <= 8 )
1943 return TRUE;
1944
1945 return FALSE;
1946 }
1947
1948 /***********************************************************************
1949 * xrenderdrv_ExtTextOut
1950 */
1951 static BOOL xrenderdrv_ExtTextOut( PHYSDEV dev, INT x, INT y, UINT flags,
1952 const RECT *lprect, LPCWSTR wstr, UINT count, const INT *lpDx )
1953 {
1954 struct xrender_physdev *physdev = get_xrender_dev( dev );
1955 XGCValues xgcval;
1956 gsCacheEntry *entry;
1957 gsCacheEntryFormat *formatEntry;
1958 BOOL retv = FALSE;
1959 int textPixel, backgroundPixel;
1960 RGNDATA *saved_region = NULL;
1961 BOOL disable_antialias = FALSE;
1962 AA_Type aa_type = AA_None;
1963 unsigned int idx;
1964 Picture tile_pict = 0;
1965
1966 if (!physdev->x11dev->has_gdi_font)
1967 {
1968 dev = GET_NEXT_PHYSDEV( dev, pExtTextOut );
1969 return dev->funcs->pExtTextOut( dev, x, y, flags, lprect, wstr, count, lpDx );
1970 }
1971
1972 if(is_dib_with_colortable( physdev->x11dev ))
1973 {
1974 TRACE("Disabling antialiasing\n");
1975 disable_antialias = TRUE;
1976 }
1977
1978 xgcval.function = GXcopy;
1979 xgcval.background = physdev->x11dev->backgroundPixel;
1980 xgcval.fill_style = FillSolid;
1981 wine_tsx11_lock();
1982 XChangeGC( gdi_display, physdev->x11dev->gc, GCFunction | GCBackground | GCFillStyle, &xgcval );
1983 wine_tsx11_unlock();
1984
1985 X11DRV_LockDIBSection( physdev->x11dev, DIB_Status_GdiMod );
1986
1987 if(physdev->x11dev->depth == 1) {
1988 if((physdev->x11dev->textPixel & 0xffffff) == 0) {
1989 textPixel = 0;
1990 backgroundPixel = 1;
1991 } else {
1992 textPixel = 1;
1993 backgroundPixel = 0;
1994 }
1995 } else {
1996 textPixel = physdev->x11dev->textPixel;
1997 backgroundPixel = physdev->x11dev->backgroundPixel;
1998 }
1999
2000 if(flags & ETO_OPAQUE)
2001 {
2002 wine_tsx11_lock();
2003 XSetForeground( gdi_display, physdev->x11dev->gc, backgroundPixel );
2004 XFillRectangle( gdi_display, physdev->x11dev->drawable, physdev->x11dev->gc,
2005 physdev->x11dev->dc_rect.left + lprect->left, physdev->x11dev->dc_rect.top + lprect->top,
2006 lprect->right - lprect->left, lprect->bottom - lprect->top );
2007 wine_tsx11_unlock();
2008 }
2009
2010 if(count == 0)
2011 {
2012 retv = TRUE;
2013 goto done_unlock;
2014 }
2015
2016 EnterCriticalSection(&xrender_cs);
2017
2018 entry = glyphsetCache + physdev->cache_index;
2019 if( disable_antialias == FALSE )
2020 aa_type = entry->aa_default;
2021 formatEntry = entry->format[aa_type];
2022
2023 for(idx = 0; idx < count; idx++) {
2024 if( !formatEntry ) {
2025 UploadGlyph(physdev, wstr[idx], aa_type);
2026 /* re-evaluate antialias since aa_default may have changed */
2027 if( disable_antialias == FALSE )
2028 aa_type = entry->aa_default;
2029 formatEntry = entry->format[aa_type];
2030 } else if( wstr[idx] >= formatEntry->nrealized || formatEntry->realized[wstr[idx]] == FALSE) {
2031 UploadGlyph(physdev, wstr[idx], aa_type);
2032 }
2033 }
2034 if (!formatEntry)
2035 {
2036 WARN("could not upload requested glyphs\n");
2037 LeaveCriticalSection(&xrender_cs);
2038 goto done_unlock;
2039 }
2040
2041 TRACE("Writing %s at %d,%d\n", debugstr_wn(wstr,count),
2042 physdev->x11dev->dc_rect.left + x, physdev->x11dev->dc_rect.top + y);
2043
2044 if(X11DRV_XRender_Installed)
2045 {
2046 XGlyphElt16 *elts = HeapAlloc(GetProcessHeap(), 0, sizeof(XGlyphElt16) * count);
2047 POINT offset = {0, 0};
2048 POINT desired, current;
2049 int render_op = PictOpOver;
2050 Picture pict = get_xrender_picture( physdev, 0, (flags & ETO_CLIPPED) ? lprect : NULL );
2051 XRenderColor col;
2052
2053 /* There's a bug in XRenderCompositeText that ignores the xDst and yDst parameters.
2054 So we pass zeros to the function and move to our starting position using the first
2055 element of the elts array. */
2056
2057 desired.x = physdev->x11dev->dc_rect.left + x;
2058 desired.y = physdev->x11dev->dc_rect.top + y;
2059 current.x = current.y = 0;
2060
2061 get_xrender_color(physdev->pict_format, physdev->x11dev->textPixel, &col);
2062 tile_pict = get_tile_pict(physdev->format, &col);
2063
2064 /* FIXME the mapping of Text/BkColor onto 1 or 0 needs investigation.
2065 */
2066 if((physdev->format == WXR_FORMAT_MONO) && (textPixel == 0))
2067 render_op = PictOpOutReverse; /* This gives us 'black' text */
2068
2069 for(idx = 0; idx < count; idx++)
2070 {
2071 elts[idx].glyphset = formatEntry->glyphset;
2072 elts[idx].chars = wstr + idx;
2073 elts[idx].nchars = 1;
2074 elts[idx].xOff = desired.x - current.x;
2075 elts[idx].yOff = desired.y - current.y;
2076
2077 current.x += (elts[idx].xOff + formatEntry->gis[wstr[idx]].xOff);
2078 current.y += (elts[idx].yOff + formatEntry->gis[wstr[idx]].yOff);
2079
2080 if(!lpDx)
2081 {
2082 desired.x += formatEntry->gis[wstr[idx]].xOff;
2083 desired.y += formatEntry->gis[wstr[idx]].yOff;
2084 }
2085 else
2086 {
2087 if(flags & ETO_PDY)
2088 {
2089 offset.x += lpDx[idx * 2];
2090 offset.y += lpDx[idx * 2 + 1];
2091 }
2092 else
2093 offset.x += lpDx[idx];
2094 desired.x = physdev->x11dev->dc_rect.left + x + offset.x;
2095 desired.y = physdev->x11dev->dc_rect.top + y + offset.y;
2096 }
2097 }
2098
2099 wine_tsx11_lock();
2100 /* Make sure we don't have any transforms set from a previous call */
2101 set_xrender_transformation(pict, 1, 1, 0, 0);
2102 pXRenderCompositeText16(gdi_display, render_op,
2103 tile_pict,
2104 pict,
2105 formatEntry->font_format,
2106 0, 0, 0, 0, elts, count);
2107 wine_tsx11_unlock();
2108 HeapFree(GetProcessHeap(), 0, elts);
2109 } else {
2110 POINT offset = {0, 0};
2111
2112 if (flags & ETO_CLIPPED)
2113 {
2114 HRGN clip_region = CreateRectRgnIndirect( lprect );
2115 saved_region = add_extra_clipping_region( physdev->x11dev, clip_region );
2116 DeleteObject( clip_region );
2117 }
2118
2119 wine_tsx11_lock();
2120 XSetForeground( gdi_display, physdev->x11dev->gc, textPixel );
2121
2122 if(aa_type == AA_None || physdev->x11dev->depth == 1)
2123 {
2124 void (* sharp_glyph_fn)(struct xrender_physdev *, INT, INT, void *, XGlyphInfo *);
2125
2126 if(aa_type == AA_None)
2127 sharp_glyph_fn = SharpGlyphMono;
2128 else
2129 sharp_glyph_fn = SharpGlyphGray;
2130
2131 for(idx = 0; idx < count; idx++) {
2132 sharp_glyph_fn(physdev,
2133 physdev->x11dev->dc_rect.left + x + offset.x,
2134 physdev->x11dev->dc_rect.top + y + offset.y,
2135 formatEntry->bitmaps[wstr[idx]],
2136 &formatEntry->gis[wstr[idx]]);
2137 if(lpDx)
2138 {
2139 if(flags & ETO_PDY)
2140 {
2141 offset.x += lpDx[idx * 2];
2142 offset.y += lpDx[idx * 2 + 1];
2143 }
2144 else
2145 offset.x += lpDx[idx];
2146 }
2147 else
2148 {
2149 offset.x += formatEntry->gis[wstr[idx]].xOff;
2150 offset.y += formatEntry->gis[wstr[idx]].yOff;
2151 }
2152 }
2153 } else {
2154 XImage *image;
2155 int image_x, image_y, image_off_x, image_off_y, image_w, image_h;
2156 RECT extents = {0, 0, 0, 0};
2157 POINT cur = {0, 0};
2158 int w = physdev->x11dev->drawable_rect.right - physdev->x11dev->drawable_rect.left;
2159 int h = physdev->x11dev->drawable_rect.bottom - physdev->x11dev->drawable_rect.top;
2160
2161 TRACE("drawable %dx%d\n", w, h);
2162
2163 for(idx = 0; idx < count; idx++) {
2164 if(extents.left > cur.x - formatEntry->gis[wstr[idx]].x)
2165 extents.left = cur.x - formatEntry->gis[wstr[idx]].x;
2166 if(extents.top > cur.y - formatEntry->gis[wstr[idx]].y)
2167 extents.top = cur.y - formatEntry->gis[wstr[idx]].y;
2168 if(extents.right < cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width)
2169 extents.right = cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width;
2170 if(extents.bottom < cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height)
2171 extents.bottom = cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height;
2172
2173 if(lpDx)
2174 {
2175 if(flags & ETO_PDY)
2176 {
2177 cur.x += lpDx[idx * 2];
2178 cur.y += lpDx[idx * 2 + 1];
2179 }
2180 else
2181 cur.x += lpDx[idx];
2182 }
2183 else
2184 {
2185 cur.x += formatEntry->gis[wstr[idx]].xOff;
2186 cur.y += formatEntry->gis[wstr[idx]].yOff;
2187 }
2188 }
2189 TRACE("glyph extents %d,%d - %d,%d drawable x,y %d,%d\n", extents.left, extents.top,
2190 extents.right, extents.bottom, physdev->x11dev->dc_rect.left + x, physdev->x11dev->dc_rect.top + y);
2191
2192 if(physdev->x11dev->dc_rect.left + x + extents.left >= 0) {
2193 image_x = physdev->x11dev->dc_rect.left + x + extents.left;
2194 image_off_x = 0;
2195 } else {
2196 image_x = 0;
2197 image_off_x = physdev->x11dev->dc_rect.left + x + extents.left;
2198 }
2199 if(physdev->x11dev->dc_rect.top + y + extents.top >= 0) {
2200 image_y = physdev->x11dev->dc_rect.top + y + extents.top;
2201 image_off_y = 0;
2202 } else {
2203 image_y = 0;
2204 image_off_y = physdev->x11dev->dc_rect.top + y + extents.top;
2205 }
2206 if(physdev->x11dev->dc_rect.left + x + extents.right < w)
2207 image_w = physdev->x11dev->dc_rect.left + x + extents.right - image_x;
2208 else
2209 image_w = w - image_x;
2210 if(physdev->x11dev->dc_rect.top + y + extents.bottom < h)
2211 image_h = physdev->x11dev->dc_rect.top + y + extents.bottom - image_y;
2212 else
2213 image_h = h - image_y;
2214
2215 if(image_w <= 0 || image_h <= 0) goto no_image;
2216
2217 X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
2218 image = XGetImage(gdi_display, physdev->x11dev->drawable,
2219 image_x, image_y, image_w, image_h,
2220 AllPlanes, ZPixmap);
2221 X11DRV_check_error();
2222
2223 TRACE("XGetImage(%p, %x, %d, %d, %d, %d, %lx, %x) depth = %d rets %p\n",
2224 gdi_display, (int)physdev->x11dev->drawable, image_x, image_y,
2225 image_w, image_h, AllPlanes, ZPixmap,
2226 physdev->x11dev->depth, image);
2227 if(!image) {
2228 Pixmap xpm = XCreatePixmap(gdi_display, root_window, image_w, image_h,
2229 physdev->x11dev->depth);
2230 GC gc;
2231 XGCValues gcv;
2232
2233 gcv.graphics_exposures = False;
2234 gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv);
2235 XCopyArea(gdi_display, physdev->x11dev->drawable, xpm, gc, image_x, image_y,
2236 image_w, image_h, 0, 0);
2237 XFreeGC(gdi_display, gc);
2238 X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
2239 image = XGetImage(gdi_display, xpm, 0, 0, image_w, image_h, AllPlanes,
2240 ZPixmap);
2241 X11DRV_check_error();
2242 XFreePixmap(gdi_display, xpm);
2243 }
2244 if(!image) goto no_image;
2245
2246 image->red_mask = visual->red_mask;
2247 image->green_mask = visual->green_mask;
2248 image->blue_mask = visual->blue_mask;
2249
2250 for(idx = 0; idx < count; idx++) {
2251 SmoothGlyphGray(image,
2252 offset.x + image_off_x - extents.left,
2253 offset.y + image_off_y - extents.top,
2254 formatEntry->bitmaps[wstr[idx]],
2255 &formatEntry->gis[wstr[idx]],
2256 physdev->x11dev->textPixel);
2257 if(lpDx)
2258 {
2259 if(flags & ETO_PDY)
2260 {
2261 offset.x += lpDx[idx * 2];
2262 offset.y += lpDx[idx * 2 + 1];
2263 }
2264 else
2265 offset.x += lpDx[idx];
2266 }
2267 else
2268 {
2269 offset.x += formatEntry->gis[wstr[idx]].xOff;
2270 offset.y += formatEntry->gis[wstr[idx]].yOff;
2271 }
2272 }
2273 XPutImage(gdi_display, physdev->x11dev->drawable, physdev->x11dev->gc, image, 0, 0,
2274 image_x, image_y, image_w, image_h);
2275 XDestroyImage(image);
2276 }
2277 no_image:
2278 wine_tsx11_unlock();
2279 restore_clipping_region( physdev->x11dev, saved_region );
2280 }
2281 LeaveCriticalSection(&xrender_cs);
2282 retv = TRUE;
2283
2284 done_unlock:
2285 X11DRV_UnlockDIBSection( physdev->x11dev, TRUE );
2286 return retv;
2287 }
2288
2289 /* multiply the alpha channel of a picture */
2290 static void multiply_alpha( Picture pict, XRenderPictFormat *format, int alpha,
2291 int x, int y, int width, int height )
2292 {
2293 XRenderPictureAttributes pa;
2294 Pixmap src_pixmap, mask_pixmap;
2295 Picture src_pict, mask_pict;
2296 XRenderColor color;
2297
2298 wine_tsx11_lock();
2299 src_pixmap = XCreatePixmap( gdi_display, root_window, 1, 1, format->depth );
2300 mask_pixmap = XCreatePixmap( gdi_display, root_window, 1, 1, format->depth );
2301 pa.repeat = RepeatNormal;
2302 src_pict = pXRenderCreatePicture( gdi_display, src_pixmap, format, CPRepeat, &pa );
2303 pa.component_alpha = True;
2304 mask_pict = pXRenderCreatePicture( gdi_display, mask_pixmap, format, CPRepeat|CPComponentAlpha, &pa );
2305 color.red = color.green = color.blue = color.alpha = 0xffff;
2306 pXRenderFillRectangle( gdi_display, PictOpSrc, src_pict, &color, 0, 0, 1, 1 );
2307 color.alpha = alpha;
2308 pXRenderFillRectangle( gdi_display, PictOpSrc, mask_pict, &color, 0, 0, 1, 1 );
2309 pXRenderComposite( gdi_display, PictOpInReverse, src_pict, mask_pict, pict,
2310 0, 0, 0, 0, x, y, width, height );
2311 pXRenderFreePicture( gdi_display, src_pict );
2312 pXRenderFreePicture( gdi_display, mask_pict );
2313 XFreePixmap( gdi_display, src_pixmap );
2314 XFreePixmap( gdi_display, mask_pixmap );
2315 wine_tsx11_unlock();
2316 }
2317
2318 /* Helper function for (stretched) blitting using xrender */
2319 static void xrender_blit( int op, Picture src_pict, Picture mask_pict, Picture dst_pict,
2320 int x_src, int y_src, int x_dst, int y_dst,
2321 double xscale, double yscale, int width, int height )
2322 {
2323 int x_offset, y_offset;
2324
2325 /* When we need to scale we perform scaling and source_x / source_y translation using a transformation matrix.
2326 * This is needed because XRender is inaccurate in combination with scaled source coordinates passed to XRenderComposite.
2327 * In all other cases we do use XRenderComposite for translation as it is faster than using a transformation matrix. */
2328 wine_tsx11_lock();
2329 if(xscale != 1.0 || yscale != 1.0)
2330 {
2331 /* In case of mirroring we need a source x- and y-offset because without the pixels will be
2332 * in the wrong quadrant of the x-y plane.
2333 */
2334 x_offset = (xscale < 0) ? -width : 0;
2335 y_offset = (yscale < 0) ? -height : 0;
2336 set_xrender_transformation(src_pict, xscale, yscale, x_src, y_src);
2337 }
2338 else
2339 {
2340 x_offset = x_src;
2341 y_offset = y_src;
2342 set_xrender_transformation(src_pict, 1, 1, 0, 0);
2343 }
2344 pXRenderComposite( gdi_display, op, src_pict, mask_pict, dst_pict,
2345 x_offset, y_offset, 0, 0, x_dst, y_dst, width, height );
2346 wine_tsx11_unlock();
2347 }
2348
2349 /* Helper function for (stretched) mono->color blitting using xrender */
2350 static void xrender_mono_blit( Picture src_pict, Picture dst_pict,
2351 enum wxr_format dst_format, XRenderColor *fg, XRenderColor *bg,
2352 int x_src, int y_src, int x_dst, int y_dst,
2353 double xscale, double yscale, int width, int height )
2354 {
2355 Picture tile_pict;
2356 int x_offset, y_offset;
2357 XRenderColor color;
2358
2359 /* When doing a mono->color blit, the source data is used as mask, and the source picture
2360 * contains a 1x1 picture for tiling. The source data effectively acts as an alpha channel to
2361 * the tile data.
2362 */
2363 EnterCriticalSection( &xrender_cs );
2364 color = *bg;
2365 color.alpha = 0xffff; /* tile pict needs 100% alpha */
2366 tile_pict = get_tile_pict( dst_format, &color );
2367
2368 wine_tsx11_lock();
2369 pXRenderFillRectangle( gdi_display, PictOpSrc, dst_pict, fg, x_dst, y_dst, width, height );
2370
2371 if (xscale != 1.0 || yscale != 1.0)
2372 {
2373 /* In case of mirroring we need a source x- and y-offset because without the pixels will be
2374 * in the wrong quadrant of the x-y plane.
2375 */
2376 x_offset = (xscale < 0) ? -width : 0;
2377 y_offset = (yscale < 0) ? -height : 0;
2378 set_xrender_transformation(src_pict, xscale, yscale, x_src, y_src);
2379 }
2380 else
2381 {
2382 x_offset = x_src;
2383 y_offset = y_src;
2384 set_xrender_transformation(src_pict, 1, 1, 0, 0);
2385 }
2386 pXRenderComposite(gdi_display, PictOpOver, tile_pict, src_pict, dst_pict,
2387 0, 0, x_offset, y_offset, x_dst, y_dst, width, height );
2388 wine_tsx11_unlock();
2389 LeaveCriticalSection( &xrender_cs );
2390
2391 /* force the alpha channel for background pixels, it has been set to 100% by the tile */
2392 if (bg->alpha != 0xffff && (dst_format == WXR_FORMAT_A8R8G8B8 || dst_format == WXR_FORMAT_B8G8R8A8))
2393 multiply_alpha( dst_pict, pict_formats[dst_format], bg->alpha, x_dst, y_dst, width, height );
2394 }
2395
2396 /* create a pixmap and render picture for an image */
2397 static DWORD create_image_pixmap( BITMAPINFO *info, const struct gdi_image_bits *bits,
2398 struct bitblt_coords *src, enum wxr_format format,
2399 Pixmap *pixmap, Picture *pict, BOOL *use_repeat )
2400 {
2401 DWORD ret;
2402 int width = src->visrect.right - src->visrect.left;
2403 int height = src->visrect.bottom - src->visrect.top;
2404 int depth = pict_formats[format]->depth;
2405 struct gdi_image_bits dst_bits;
2406 XRenderPictureAttributes pa;
2407 XImage *image;
2408
2409 wine_tsx11_lock();
2410 image = XCreateImage( gdi_display, visual, depth, ZPixmap, 0, NULL,
2411 info->bmiHeader.biWidth, height, 32, 0 );
2412 wine_tsx11_unlock();
2413 if (!image) return ERROR_OUTOFMEMORY;
2414
2415 ret = copy_image_bits( info, (format == WXR_FORMAT_R8G8B8), image, bits, &dst_bits, src, NULL, ~0u );
2416 if (ret) return ret;
2417
2418 image->data = dst_bits.ptr;
2419 /* hack: make sure the bits are readable if we are reading from a DIB section */
2420 /* to be removed once we get rid of DIB access protections */
2421 if (!dst_bits.is_copy) IsBadReadPtr( dst_bits.ptr, image->height * image->bytes_per_line );
2422
2423 *use_repeat = (width == 1 && height == 1);
2424 pa.repeat = *use_repeat ? RepeatNormal : RepeatNone;
2425
2426 wine_tsx11_lock();
2427 *pixmap = XCreatePixmap( gdi_display, root_window, width, height, depth );
2428 XPutImage( gdi_display, *pixmap, get_bitmap_gc( depth ), image,
2429 src->visrect.left, 0, 0, 0, width, height );
2430 *pict = pXRenderCreatePicture( gdi_display, *pixmap, pict_formats[format], CPRepeat, &pa );
2431 wine_tsx11_unlock();
2432
2433 /* make coordinates relative to the pixmap */
2434 src->x -= src->visrect.left;
2435 src->y -= src->visrect.top;
2436 OffsetRect( &src->visrect, -src->visrect.left, -src->visrect.top );
2437
2438 image->data = NULL;
2439 wine_tsx11_lock();
2440 XDestroyImage( image );
2441 wine_tsx11_unlock();
2442 if (dst_bits.free) dst_bits.free( &dst_bits );
2443 return ret;
2444 }
2445
2446 static void xrender_stretch_blit( struct xrender_physdev *physdev_src, struct xrender_physdev *physdev_dst,
2447 Drawable drawable, const struct bitblt_coords *src,
2448 const struct bitblt_coords *dst )
2449 {
2450 int width = abs( dst->width );
2451 int height = abs( dst->height );
2452 int x_src = physdev_src->x11dev->dc_rect.left + src->x;
2453 int y_src = physdev_src->x11dev->dc_rect.top + src->y;
2454 int x_dst, y_dst;
2455 Picture src_pict = 0, dst_pict, mask_pict = 0;
2456 BOOL use_repeat;
2457 double xscale, yscale;
2458
2459 use_repeat = use_source_repeat( physdev_src );
2460 if (!use_repeat)
2461 {
2462 xscale = src->width / (double)dst->width;
2463 yscale = src->height / (double)dst->height;
2464 }
2465 else xscale = yscale = 1; /* no scaling needed with a repeating source */
2466
2467 if (drawable) /* using an intermediate pixmap */
2468 {
2469 XRenderPictureAttributes pa;
2470
2471 x_dst = dst->x;
2472 y_dst = dst->y;
2473 pa.repeat = RepeatNone;
2474 wine_tsx11_lock();
2475 dst_pict = pXRenderCreatePicture( gdi_display, drawable, physdev_dst->pict_format, CPRepeat, &pa );
2476 wine_tsx11_unlock();
2477 }
2478 else
2479 {
2480 x_dst = physdev_dst->x11dev->dc_rect.left + dst->x;
2481 y_dst = physdev_dst->x11dev->dc_rect.top + dst->y;
2482 dst_pict = get_xrender_picture( physdev_dst, 0, &dst->visrect );
2483 }
2484
2485 if (src->width < 0) x_src += src->width + 1;
2486 if (src->height < 0) y_src += src->height + 1;
2487 if (dst->width < 0) x_dst += dst->width + 1;
2488 if (dst->height < 0) y_dst += dst->height + 1;
2489
2490 src_pict = get_xrender_picture_source( physdev_src, use_repeat );
2491
2492 /* mono -> color */
2493 if (physdev_src->format == WXR_FORMAT_MONO && physdev_dst->format != WXR_FORMAT_MONO)
2494 {
2495 XRenderColor fg, bg;
2496
2497 get_xrender_color( physdev_dst->pict_format, physdev_dst->x11dev->textPixel, &fg );
2498 get_xrender_color( physdev_dst->pict_format, physdev_dst->x11dev->backgroundPixel, &bg );
2499 fg.alpha = bg.alpha = 0;
2500
2501 xrender_mono_blit( src_pict, dst_pict, physdev_dst->format, &fg, &bg,
2502 x_src, y_src, x_dst, y_dst, xscale, yscale, width, height );
2503 }
2504 else /* color -> color (can be at different depths) or mono -> mono */
2505 {
2506 if (physdev_dst->x11dev->depth == 32 && physdev_src->x11dev->depth < 32)
2507 mask_pict = get_no_alpha_mask();
2508
2509 xrender_blit( PictOpSrc, src_pict, mask_pict, dst_pict,
2510 x_src, y_src, x_dst, y_dst, xscale, yscale, width, height );
2511 }
2512
2513 if (drawable)
2514 {
2515 wine_tsx11_lock();
2516 pXRenderFreePicture( gdi_display, dst_pict );
2517 wine_tsx11_unlock();
2518 }
2519 }
2520
2521
2522 static void xrender_put_image( Pixmap src_pixmap, Picture src_pict, Picture mask_pict, HRGN clip,
2523 XRenderPictFormat *dst_format, struct xrender_physdev *physdev,
2524 Drawable drawable, struct bitblt_coords *src,
2525 struct bitblt_coords *dst, BOOL use_repeat )
2526 {
2527 int x_src, y_src, x_dst, y_dst;
2528 Picture dst_pict;
2529 XRenderPictureAttributes pa;
2530 double xscale, yscale;
2531
2532 if (drawable) /* using an intermediate pixmap */
2533 {
2534 RGNDATA *clip_data = NULL;
2535
2536 if (clip) clip_data = X11DRV_GetRegionData( clip, 0 );
2537 x_dst = dst->x;
2538 y_dst = dst->y;
2539 pa.repeat = RepeatNone;
2540 wine_tsx11_lock();
2541 dst_pict = pXRenderCreatePicture( gdi_display, drawable, dst_format, CPRepeat, &pa );
2542 if (clip_data)
2543 pXRenderSetPictureClipRectangles( gdi_display, dst_pict, 0, 0,
2544 (XRectangle *)clip_data->Buffer, clip_data->rdh.nCount );
2545 wine_tsx11_unlock();
2546 HeapFree( GetProcessHeap(), 0, clip_data );
2547 }
2548 else
2549 {
2550 x_dst = physdev->x11dev->dc_rect.left + dst->x;
2551 y_dst = physdev->x11dev->dc_rect.top + dst->y;
2552 dst_pict = get_xrender_picture( physdev, clip, &dst->visrect );
2553 }
2554
2555 if (!use_repeat)
2556 {
2557 xscale = src->width / (double)dst->width;
2558 yscale = src->height / (double)dst->height;
2559 }
2560 else xscale = yscale = 1; /* no scaling needed with a repeating source */
2561
2562 x_src = src->x;
2563 y_src = src->y;
2564 if (src->width < 0) x_src += src->width + 1;
2565 if (src->height < 0) y_src += src->height + 1;
2566 if (dst->width < 0) x_dst += dst->width + 1;
2567 if (dst->height < 0) y_dst += dst->height + 1;
2568
2569 xrender_blit( PictOpSrc, src_pict, mask_pict, dst_pict, x_src, y_src, x_dst, y_dst,
2570 xscale, yscale, abs( dst->width ), abs( dst->height ));
2571
2572 if (drawable)
2573 {
2574 wine_tsx11_lock();
2575 pXRenderFreePicture( gdi_display, dst_pict );
2576 wine_tsx11_unlock();
2577 }
2578 }
2579
2580
2581 /***********************************************************************
2582 * xrenderdrv_StretchBlt
2583 */
2584 static BOOL xrenderdrv_StretchBlt( PHYSDEV dst_dev, struct bitblt_coords *dst,
2585 PHYSDEV src_dev, struct bitblt_coords *src, DWORD rop )
2586 {
2587 struct xrender_physdev *physdev_dst = get_xrender_dev( dst_dev );
2588 struct xrender_physdev *physdev_src = get_xrender_dev( src_dev );
2589 BOOL stretch = (src->width != dst->width) || (src->height != dst->height);
2590
2591 if (src_dev->funcs != dst_dev->funcs)
2592 {
2593 dst_dev = GET_NEXT_PHYSDEV( dst_dev, pStretchBlt );
2594 return dst_dev->funcs->pStretchBlt( dst_dev, dst, src_dev, src, rop );
2595 }
2596
2597 if (!X11DRV_XRender_Installed) goto x11drv_fallback;
2598
2599 /* XRender is of no use for color -> mono */
2600 if (physdev_dst->format == WXR_FORMAT_MONO && physdev_src->format != WXR_FORMAT_MONO)
2601 goto x11drv_fallback;
2602
2603 /* if not stretching, we only need to handle format conversion */
2604 if (!stretch && physdev_dst->format == physdev_src->format) goto x11drv_fallback;
2605
2606 X11DRV_LockDIBSection( physdev_dst->x11dev, DIB_Status_GdiMod );
2607 if (physdev_dst != physdev_src) X11DRV_LockDIBSection( physdev_src->x11dev, DIB_Status_GdiMod );
2608
2609 if (rop != SRCCOPY)
2610 {
2611 GC tmpGC;
2612 Pixmap tmp_pixmap;
2613 struct bitblt_coords tmp;
2614
2615 /* make coordinates relative to tmp pixmap */
2616 tmp = *dst;
2617 tmp.x -= tmp.visrect.left;
2618 tmp.y -= tmp.visrect.top;
2619 OffsetRect( &tmp.visrect, -tmp.visrect.left, -tmp.visrect.top );
2620
2621 wine_tsx11_lock();
2622 tmpGC = XCreateGC( gdi_display, physdev_dst->x11dev->drawable, 0, NULL );
2623 XSetSubwindowMode( gdi_display, tmpGC, IncludeInferiors );
2624 XSetGraphicsExposures( gdi_display, tmpGC, False );
2625 tmp_pixmap = XCreatePixmap( gdi_display, root_window, tmp.visrect.right - tmp.visrect.left,
2626 tmp.visrect.bottom - tmp.visrect.top, physdev_dst->x11dev->depth );
2627 wine_tsx11_unlock();
2628
2629 xrender_stretch_blit( physdev_src, physdev_dst, tmp_pixmap, src, &tmp );
2630 execute_rop( physdev_dst->x11dev, tmp_pixmap, tmpGC, &dst->visrect, rop );
2631
2632 wine_tsx11_lock();
2633 XFreePixmap( gdi_display, tmp_pixmap );
2634 XFreeGC( gdi_display, tmpGC );
2635 wine_tsx11_unlock();
2636 }
2637 else xrender_stretch_blit( physdev_src, physdev_dst, 0, src, dst );
2638
2639 if (physdev_dst != physdev_src) X11DRV_UnlockDIBSection( physdev_src->x11dev, FALSE );
2640 X11DRV_UnlockDIBSection( physdev_dst->x11dev, TRUE );
2641 return TRUE;
2642
2643 x11drv_fallback:
2644 return X11DRV_StretchBlt( &physdev_dst->x11dev->dev, dst, &physdev_src->x11dev->dev, src, rop );
2645 }
2646
2647
2648 /***********************************************************************
2649 * xrenderdrv_PutImage
2650 */
2651 static DWORD xrenderdrv_PutImage( PHYSDEV dev, HBITMAP hbitmap, HRGN clip, BITMAPINFO *info,
2652 const struct gdi_image_bits *bits, struct bitblt_coords *src,
2653 struct bitblt_coords *dst, DWORD rop )
2654 {
2655 struct xrender_physdev *physdev;
2656 X_PHYSBITMAP *bitmap;
2657 DWORD ret;
2658 Pixmap tmp_pixmap;
2659 GC gc;
2660 enum wxr_format src_format, dst_format;
2661 XRenderPictFormat *pict_format;
2662 Pixmap src_pixmap;
2663 Picture src_pict, mask_pict = 0;
2664 BOOL use_repeat;
2665
2666 if (!X11DRV_XRender_Installed) goto x11drv_fallback;
2667
2668 if (hbitmap)
2669 {
2670 if (!(bitmap = X11DRV_get_phys_bitmap( hbitmap ))) return ERROR_INVALID_HANDLE;
2671 physdev = NULL;
2672 dst_format = get_xrender_format_from_color_shifts( bitmap->depth, &bitmap->color_shifts );
2673 }
2674 else
2675 {
2676 physdev = get_xrender_dev( dev );
2677 bitmap = NULL;
2678 dst_format = physdev->format;
2679 }
2680
2681 src_format = get_xrender_format_from_bitmapinfo( info, TRUE );
2682 if (!(pict_format = pict_formats[src_format])) goto update_format;
2683
2684 /* make sure we can create an image with the same bpp */
2685 if (info->bmiHeader.biBitCount != pixmap_formats[pict_format->depth]->bits_per_pixel)
2686 goto update_format;
2687
2688 /* mono <-> color conversions not supported */
2689 if ((src_format != dst_format) && (src_format == WXR_FORMAT_MONO || dst_format == WXR_FORMAT_MONO))
2690 goto x11drv_fallback;
2691
2692 if (!bits) return ERROR_SUCCESS; /* just querying the format */
2693
2694 if (!has_alpha( src_format ) && has_alpha( dst_format )) mask_pict = get_no_alpha_mask();
2695
2696 ret = create_image_pixmap( info, bits, src, src_format, &src_pixmap, &src_pict, &use_repeat );
2697 if (!ret)
2698 {
2699 struct bitblt_coords tmp;
2700
2701 if (bitmap)
2702 {
2703 HRGN rgn = CreateRectRgnIndirect( &dst->visrect );
2704 if (clip) CombineRgn( rgn, rgn, clip, RGN_AND );
2705
2706 X11DRV_DIB_Lock( bitmap, DIB_Status_GdiMod );
2707
2708 xrender_put_image( src_pixmap, src_pict, mask_pict, rgn,
2709 pict_formats[dst_format], NULL, bitmap->pixmap, src, dst, use_repeat );
2710
2711 X11DRV_DIB_Unlock( bitmap, TRUE );
2712 DeleteObject( rgn );
2713 }
2714 else
2715 {
2716 X11DRV_LockDIBSection( physdev->x11dev, DIB_Status_GdiMod );
2717
2718 if (rop != SRCCOPY)
2719 {
2720 RGNDATA *clip_data = NULL;
2721
2722 /* make coordinates relative to tmp pixmap */
2723 tmp = *dst;
2724 tmp.x -= tmp.visrect.left;
2725 tmp.y -= tmp.visrect.top;
2726 OffsetRect( &tmp.visrect, -tmp.visrect.left, -tmp.visrect.top );
2727
2728 if (clip) clip_data = add_extra_clipping_region( physdev->x11dev, clip );
2729
2730 wine_tsx11_lock();
2731 gc = XCreateGC( gdi_display, physdev->x11dev->drawable, 0, NULL );
2732 XSetSubwindowMode( gdi_display, gc, IncludeInferiors );
2733 XSetGraphicsExposures( gdi_display, gc, False );
2734 tmp_pixmap = XCreatePixmap( gdi_display, root_window, tmp.visrect.right - tmp.visrect.left,
2735 tmp.visrect.bottom - tmp.visrect.top, physdev->x11dev->depth );
2736 wine_tsx11_unlock();
2737
2738 xrender_put_image( src_pixmap, src_pict, mask_pict, NULL, physdev->pict_format,
2739 NULL, tmp_pixmap, src, &tmp, use_repeat );
2740 execute_rop( physdev->x11dev, tmp_pixmap, gc, &dst->visrect, rop );
2741
2742 wine_tsx11_lock();
2743 XFreePixmap( gdi_display, tmp_pixmap );
2744 XFreeGC( gdi_display, gc );
2745 wine_tsx11_unlock();
2746
2747 restore_clipping_region( physdev->x11dev, clip_data );
2748 }
2749 else xrender_put_image( src_pixmap, src_pict, mask_pict, clip,
2750 physdev->pict_format, physdev, 0, src, dst, use_repeat );
2751
2752 X11DRV_UnlockDIBSection( physdev->x11dev, TRUE );
2753 }
2754
2755 wine_tsx11_lock();
2756 pXRenderFreePicture( gdi_display, src_pict );
2757 XFreePixmap( gdi_display, src_pixmap );
2758 wine_tsx11_unlock();
2759 }
2760 return ret;
2761
2762 update_format:
2763 if (info->bmiHeader.biHeight > 0) info->bmiHeader.biHeight = -info->bmiHeader.biHeight;
2764 set_color_info( pict_formats[dst_format], info );
2765 return ERROR_BAD_FORMAT;
2766
2767 x11drv_fallback:
2768 if (hbitmap) return X11DRV_PutImage( dev, hbitmap, clip, info, bits, src, dst, rop );
2769 dev = GET_NEXT_PHYSDEV( dev, pPutImage );
2770 return dev->funcs->pPutImage( dev, hbitmap, clip, info, bits, src, dst, rop );
2771 }
2772
2773
2774 /***********************************************************************
2775 * xrenderdrv_BlendImage
2776 */
2777 static DWORD xrenderdrv_BlendImage( PHYSDEV dev, BITMAPINFO *info, const struct gdi_image_bits *bits,
2778 struct bitblt_coords *src, struct bitblt_coords *dst,
2779 BLENDFUNCTION func )
2780 {
2781 struct xrender_physdev *physdev = get_xrender_dev( dev );
2782 DWORD ret;
2783 enum wxr_format format;
2784 XRenderPictFormat *pict_format;
2785 Picture dst_pict, src_pict, mask_pict;
2786 Pixmap src_pixmap;
2787 BOOL use_repeat;
2788
2789 if (!X11DRV_XRender_Installed)
2790 {
2791 dev = GET_NEXT_PHYSDEV( dev, pBlendImage );
2792 return dev->funcs->pBlendImage( dev, info, bits, src, dst, func );
2793 }
2794
2795 format = get_xrender_format_from_bitmapinfo( info, func.AlphaFormat & AC_SRC_ALPHA );
2796 if (!(pict_format = pict_formats[format])) goto update_format;
2797
2798 /* make sure we can create an image with the same bpp */
2799 if (info->bmiHeader.biBitCount != pixmap_formats[pict_format->depth]->bits_per_pixel)
2800 goto update_format;
2801
2802 if (format == WXR_FORMAT_MONO && physdev->format != WXR_FORMAT_MONO)
2803 goto update_format;
2804
2805 if (!bits) return ERROR_SUCCESS; /* just querying the format */
2806
2807 ret = create_image_pixmap( info, bits, src, format, &src_pixmap, &src_pict, &use_repeat );
2808 if (!ret)
2809 {
2810 double xscale, yscale;
2811
2812 X11DRV_LockDIBSection( physdev->x11dev, DIB_Status_GdiMod );
2813
2814 if (!use_repeat)
2815 {
2816 xscale = src->width / (double)dst->width;
2817 yscale = src->height / (double)dst->height;
2818 }
2819 else xscale = yscale = 1; /* no scaling needed with a repeating source */
2820
2821 dst_pict = get_xrender_picture( physdev, 0, &dst->visrect );
2822
2823 EnterCriticalSection( &xrender_cs );
2824 mask_pict = get_mask_pict( func.SourceConstantAlpha * 257 );
2825
2826 xrender_blit( PictOpOver, src_pict, mask_pict, dst_pict, src->x, src->y,
2827 physdev->x11dev->dc_rect.left + dst->x,
2828 physdev->x11dev->dc_rect.top + dst->y,
2829 xscale, yscale, dst->width, dst->height );
2830
2831 wine_tsx11_lock();
2832 pXRenderFreePicture( gdi_display, src_pict );
2833 XFreePixmap( gdi_display, src_pixmap );
2834 wine_tsx11_unlock();
2835
2836 LeaveCriticalSection( &xrender_cs );
2837
2838 X11DRV_UnlockDIBSection( physdev->x11dev, TRUE );
2839 }
2840 return ret;
2841
2842 update_format:
2843 if (info->bmiHeader.biHeight > 0) info->bmiHeader.biHeight = -info->bmiHeader.biHeight;
2844 set_color_info( physdev->pict_format, info );
2845 return ERROR_BAD_FORMAT;
2846 }
2847
2848
2849 /***********************************************************************
2850 * xrenderdrv_AlphaBlend
2851 */
2852 static BOOL xrenderdrv_AlphaBlend( PHYSDEV dst_dev, struct bitblt_coords *dst,
2853 PHYSDEV src_dev, struct bitblt_coords *src, BLENDFUNCTION blendfn )
2854 {
2855 struct xrender_physdev *physdev_dst = get_xrender_dev( dst_dev );
2856 struct xrender_physdev *physdev_src = get_xrender_dev( src_dev );
2857 Picture dst_pict, src_pict = 0, mask_pict = 0, tmp_pict = 0;
2858 XRenderPictureAttributes pa;
2859 Pixmap tmp_pixmap = 0;
2860 double xscale, yscale;
2861 BOOL use_repeat;
2862
2863 if (!X11DRV_XRender_Installed || src_dev->funcs != dst_dev->funcs)
2864 {
2865 dst_dev = GET_NEXT_PHYSDEV( dst_dev, pAlphaBlend );
2866 return dst_dev->funcs->pAlphaBlend( dst_dev, dst, src_dev, src, blendfn );
2867 }
2868
2869 if (physdev_dst != physdev_src)
2870 {
2871 int status = X11DRV_LockDIBSection( physdev_src->x11dev, DIB_Status_None );
2872 if (status == DIB_Status_AppMod || status == DIB_Status_InSync)
2873 {
2874 X11DRV_UnlockDIBSection( physdev_src->x11dev, FALSE );
2875 dst_dev = GET_NEXT_PHYSDEV( dst_dev, pAlphaBlend );
2876 return dst_dev->funcs->pAlphaBlend( dst_dev, dst, src_dev, src, blendfn );
2877 }
2878 X11DRV_CoerceDIBSection( physdev_src->x11dev, DIB_Status_GdiMod );
2879 }
2880 X11DRV_LockDIBSection( physdev_dst->x11dev, DIB_Status_GdiMod );
2881
2882 dst_pict = get_xrender_picture( physdev_dst, 0, &dst->visrect );
2883
2884 use_repeat = use_source_repeat( physdev_src );
2885 if (!use_repeat)
2886 {
2887 xscale = src->width / (double)dst->width;
2888 yscale = src->height / (double)dst->height;
2889 }
2890 else xscale = yscale = 1; /* no scaling needed with a repeating source */
2891
2892 src_pict = get_xrender_picture_source( physdev_src, use_repeat );
2893
2894 if (physdev_src->format == WXR_FORMAT_MONO && physdev_dst->format != WXR_FORMAT_MONO)
2895 {
2896 /* mono -> color blending needs an intermediate color pixmap */
2897 XRenderColor fg, bg;
2898 int width = src->visrect.right - src->visrect.left;
2899 int height = src->visrect.bottom - src->visrect.top;
2900
2901 /* blending doesn't use the destination DC colors */
2902 fg.red = fg.green = fg.blue = 0;
2903 bg.red = bg.green = bg.blue = 0xffff;
2904 fg.alpha = bg.alpha = 0xffff;
2905
2906 wine_tsx11_lock();
2907 tmp_pixmap = XCreatePixmap( gdi_display, root_window, width, height,
2908 physdev_dst->pict_format->depth );
2909 pa.repeat = use_repeat ? RepeatNormal : RepeatNone;
2910 tmp_pict = pXRenderCreatePicture( gdi_display, tmp_pixmap, physdev_dst->pict_format,
2911 CPRepeat, &pa );
2912 wine_tsx11_unlock();
2913
2914 xrender_mono_blit( src_pict, tmp_pict, physdev_dst->format, &fg, &bg,
2915 src->visrect.left, src->visrect.top, 0, 0, 1, 1, width, height );
2916 }
2917 else if (!(blendfn.AlphaFormat & AC_SRC_ALPHA) && physdev_src->pict_format)
2918 {
2919 /* we need a source picture with no alpha */
2920 enum wxr_format format = get_format_without_alpha( physdev_src->format );
2921 if (format != physdev_src->format)
2922 {
2923 wine_tsx11_lock();
2924 pa.subwindow_mode = IncludeInferiors;
2925 pa.repeat = use_repeat ? RepeatNormal : RepeatNone;
2926 tmp_pict = pXRenderCreatePicture( gdi_display, physdev_src->x11dev->drawable,
2927 pict_formats[format], CPSubwindowMode|CPRepeat, &pa );
2928 wine_tsx11_unlock();
2929 }
2930 }
2931
2932 if (tmp_pict) src_pict = tmp_pict;
2933
2934 EnterCriticalSection( &xrender_cs );
2935 mask_pict = get_mask_pict( blendfn.SourceConstantAlpha * 257 );
2936
2937 xrender_blit( PictOpOver, src_pict, mask_pict, dst_pict,
2938 physdev_src->x11dev->dc_rect.left + src->x,
2939 physdev_src->x11dev->dc_rect.top + src->y,
2940 physdev_dst->x11dev->dc_rect.left + dst->x,
2941 physdev_dst->x11dev->dc_rect.top + dst->y,
2942 xscale, yscale, dst->width, dst->height );
2943
2944 wine_tsx11_lock();
2945 if (tmp_pict) pXRenderFreePicture( gdi_display, tmp_pict );
2946 if (tmp_pixmap) XFreePixmap( gdi_display, tmp_pixmap );
2947 wine_tsx11_unlock();
2948
2949 LeaveCriticalSection( &xrender_cs );
2950 if (physdev_src != physdev_dst) X11DRV_UnlockDIBSection( physdev_src->x11dev, FALSE );
2951 X11DRV_UnlockDIBSection( physdev_dst->x11dev, TRUE );
2952 return TRUE;
2953 }
2954
2955
2956 void X11DRV_XRender_CopyBrush(X11DRV_PDEVICE *physDev, X_PHYSBITMAP *physBitmap, int width, int height)
2957 {
2958 /* 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 */
2959 int depth = physBitmap->depth == 1 ? 1 : physDev->depth;
2960 enum wxr_format src_format = get_xrender_format_from_color_shifts(physBitmap->depth, &physBitmap->color_shifts);
2961 enum wxr_format dst_format = get_xrender_format_from_color_shifts(physDev->depth, physDev->color_shifts);
2962
2963 wine_tsx11_lock();
2964 physDev->brush.pixmap = XCreatePixmap(gdi_display, root_window, width, height, depth);
2965
2966 /* Use XCopyArea when the physBitmap and brush.pixmap have the same format. */
2967 if( (physBitmap->depth == 1) || (!X11DRV_XRender_Installed && physDev->depth == physBitmap->depth) ||
2968 (src_format == dst_format) )
2969 {
2970 XCopyArea( gdi_display, physBitmap->pixmap, physDev->brush.pixmap,
2971 get_bitmap_gc(physBitmap->depth), 0, 0, width, height, 0, 0 );
2972 }
2973 else /* We need depth conversion */
2974 {
2975 Picture src_pict, dst_pict;
2976 XRenderPictureAttributes pa;
2977 pa.subwindow_mode = IncludeInferiors;
2978 pa.repeat = RepeatNone;
2979
2980 src_pict = pXRenderCreatePicture(gdi_display, physBitmap->pixmap,
2981 pict_formats[src_format], CPSubwindowMode|CPRepeat, &pa);
2982 dst_pict = pXRenderCreatePicture(gdi_display, physDev->brush.pixmap,
2983 pict_formats[dst_format], CPSubwindowMode|CPRepeat, &pa);
2984
2985 xrender_blit(PictOpSrc, src_pict, 0, dst_pict, 0, 0, 0, 0, 1.0, 1.0, width, height);
2986 pXRenderFreePicture(gdi_display, src_pict);
2987 pXRenderFreePicture(gdi_display, dst_pict);
2988 }
2989 wine_tsx11_unlock();
2990 }
2991
2992 static const struct gdi_dc_funcs xrender_funcs =
2993 {
2994 NULL, /* pAbortDoc */
2995 NULL, /* pAbortPath */
2996 xrenderdrv_AlphaBlend, /* pAlphaBlend */
2997 NULL, /* pAngleArc */
2998 NULL, /* pArc */
2999 NULL, /* pArcTo */
3000 NULL, /* pBeginPath */
3001 xrenderdrv_BlendImage, /* pBlendImage */
3002 NULL, /* pChoosePixelFormat */
3003 NULL, /* pChord */
3004 NULL, /* pCloseFigure */
3005 xrenderdrv_CreateBitmap, /* pCreateBitmap */
3006 xrenderdrv_CreateCompatibleDC, /* pCreateCompatibleDC */
3007 xrenderdrv_CreateDC, /* pCreateDC */
3008 NULL, /* pCreateDIBSection */
3009 xrenderdrv_DeleteBitmap, /* pDeleteBitmap */
3010 xrenderdrv_DeleteDC, /* pDeleteDC */
3011 NULL, /* pDeleteObject */
3012 NULL, /* pDescribePixelFormat */
3013 NULL, /* pDeviceCapabilities */
3014 NULL, /* pEllipse */
3015 NULL, /* pEndDoc */
3016 NULL, /* pEndPage */
3017 NULL, /* pEndPath */
3018 NULL, /* pEnumDeviceFonts */
3019 NULL, /* pEnumICMProfiles */
3020 NULL, /* pExcludeClipRect */
3021 NULL, /* pExtDeviceMode */
3022 xrenderdrv_ExtEscape, /* pExtEscape */
3023 NULL, /* pExtFloodFill */
3024 NULL, /* pExtSelectClipRgn */
3025 xrenderdrv_ExtTextOut, /* pExtTextOut */
3026 NULL, /* pFillPath */
3027 NULL, /* pFillRgn */
3028 NULL, /* pFlattenPath */
3029 NULL, /* pFrameRgn */
3030 NULL, /* pGdiComment */
3031 NULL, /* pGetCharWidth */
3032 NULL, /* pGetDeviceCaps */
3033 NULL, /* pGetDeviceGammaRamp */
3034 NULL, /* pGetICMProfile */
3035 xrenderdrv_GetImage, /* pGetImage */
3036 NULL, /* pGetNearestColor */
3037 NULL, /* pGetPixel */
3038 NULL, /* pGetPixelFormat */
3039 NULL, /* pGetSystemPaletteEntries */
3040 NULL, /* pGetTextExtentExPoint */
3041 NULL, /* pGetTextMetrics */
3042 NULL, /* pIntersectClipRect */
3043 NULL, /* pInvertRgn */
3044 NULL, /* pLineTo */
3045 NULL, /* pModifyWorldTransform */
3046 NULL, /* pMoveTo */
3047 NULL, /* pOffsetClipRgn */
3048 NULL, /* pOffsetViewportOrg */
3049 NULL, /* pOffsetWindowOrg */
3050 NULL, /* pPaintRgn */
3051 NULL, /* pPatBlt */
3052 NULL, /* pPie */
3053 NULL, /* pPolyBezier */
3054 NULL, /* pPolyBezierTo */
3055 NULL, /* pPolyDraw */
3056 NULL, /* pPolyPolygon */
3057 NULL, /* pPolyPolyline */
3058 NULL, /* pPolygon */
3059 NULL, /* pPolyline */
3060 NULL, /* pPolylineTo */
3061 xrenderdrv_PutImage, /* pPutImage */
3062 NULL, /* pRealizeDefaultPalette */
3063 NULL, /* pRealizePalette */
3064 NULL, /* pRectangle */
3065 NULL, /* pResetDC */
3066 NULL, /* pRestoreDC */
3067 NULL, /* pRoundRect */
3068 NULL, /* pSaveDC */
3069 NULL, /* pScaleViewportExt */
3070 NULL, /* pScaleWindowExt */
3071 xrenderdrv_SelectBitmap, /* pSelectBitmap */
3072 NULL, /* pSelectBrush */
3073 NULL, /* pSelectClipPath */
3074 xrenderdrv_SelectFont, /* pSelectFont */
3075 NULL, /* pSelectPalette */
3076 NULL, /* pSelectPen */
3077 NULL, /* pSetArcDirection */
3078 NULL, /* pSetBkColor */
3079 NULL, /* pSetBkMode */
3080 NULL, /* pSetDCBrushColor */
3081 NULL, /* pSetDCPenColor */
3082 NULL, /* pSetDIBColorTable */
3083 NULL, /* pSetDIBitsToDevice */
3084 xrenderdrv_SetDeviceClipping, /* pSetDeviceClipping */
3085 NULL, /* pSetDeviceGammaRamp */
3086 NULL, /* pSetLayout */
3087 NULL, /* pSetMapMode */
3088 NULL, /* pSetMapperFlags */
3089 NULL, /* pSetPixel */
3090 NULL, /* pSetPixelFormat */
3091 NULL, /* pSetPolyFillMode */
3092 NULL, /* pSetROP2 */
3093 NULL, /* pSetRelAbs */
3094 NULL, /* pSetStretchBltMode */
3095 NULL, /* pSetTextAlign */
3096 NULL, /* pSetTextCharacterExtra */
3097 NULL, /* pSetTextColor */
3098 NULL, /* pSetTextJustification */
3099 NULL, /* pSetViewportExt */
3100 NULL, /* pSetViewportOrg */
3101 NULL, /* pSetWindowExt */
3102 NULL, /* pSetWindowOrg */
3103 NULL, /* pSetWorldTransform */
3104 NULL, /* pStartDoc */
3105 NULL, /* pStartPage */
3106 xrenderdrv_StretchBlt, /* pStretchBlt */
3107 NULL, /* pStretchDIBits */
3108 NULL, /* pStrokeAndFillPath */
3109 NULL, /* pStrokePath */
3110 NULL, /* pSwapBuffers */
3111 NULL, /* pUnrealizePalette */
3112 NULL, /* pWidenPath */
3113 /* OpenGL not supported */
3114 };
3115
3116 #else /* SONAME_LIBXRENDER */
3117
3118 const struct gdi_dc_funcs *X11DRV_XRender_Init(void)
3119 {
3120 TRACE("XRender support not compiled in.\n");
3121 return NULL;
3122 }
3123
3124 void X11DRV_XRender_Finalize(void)
3125 {
3126 }
3127
3128 void X11DRV_XRender_CopyBrush(X11DRV_PDEVICE *physDev, X_PHYSBITMAP *physBitmap, int width, int height)
3129 {
3130 wine_tsx11_lock();
3131 physDev->brush.pixmap = XCreatePixmap(gdi_display, root_window, width, height, physBitmap->pixmap_depth);
3132
3133 XCopyArea( gdi_display, physBitmap->pixmap, physDev->brush.pixmap,
3134 get_bitmap_gc(physBitmap->pixmap_depth), 0, 0, width, height, 0, 0 );
3135 wine_tsx11_unlock();
3136 }
3137
3138 BOOL X11DRV_XRender_SetPhysBitmapDepth(X_PHYSBITMAP *physBitmap, int bits_pixel, const DIBSECTION *dib)
3139 {
3140 return FALSE;
3141 }
3142
3143 #endif /* SONAME_LIBXRENDER */
Quick hack tree for wine patches julliard doesn't want to commit