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