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