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