?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sane.ds: Remove an unused debug channel.
[wine/multimedia.git] / dlls / winex11.drv / xrender.c
blobf4b68ffa5216ba7463f34b9c52394dc67a0cf778
1 /*
2 * Functions to use the XRender extension
3 *
4 * Copyright 2001, 2002 Huw D M Davies for CodeWeavers
5 *
6 * Some parts also:
7 * Copyright 2000 Keith Packard, member of The XFree86 Project, Inc.
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <stdarg.h>
28 #include <string.h>
29 #include <stdlib.h>
30
31 #include "windef.h"
32 #include "winbase.h"
33 #include "x11drv.h"
34 #include "winternl.h"
35 #include "wine/library.h"
36 #include "wine/unicode.h"
37 #include "wine/debug.h"
38
39 int using_client_side_fonts = FALSE;
40
41 WINE_DEFAULT_DEBUG_CHANNEL(xrender);
42
43 #ifdef SONAME_LIBXRENDER
44
45 static BOOL X11DRV_XRender_Installed = FALSE;
46
47 #include <X11/Xlib.h>
48 #include <X11/extensions/Xrender.h>
49
50
51 enum drawable_depth_type {mono_drawable, color_drawable};
52 static XRenderPictFormat *pict_formats[2];
53
54 typedef struct
55 {
56 LOGFONTW lf;
57 XFORM xform;
58 SIZE devsize; /* size in device coords */
59 DWORD hash;
60 } LFANDSIZE;
61
62 #define INITIAL_REALIZED_BUF_SIZE 128
63
64 typedef enum { AA_None = 0, AA_Grey, AA_RGB, AA_BGR, AA_VRGB, AA_VBGR, AA_MAXVALUE } AA_Type;
65
66 typedef struct
67 {
68 GlyphSet glyphset;
69 XRenderPictFormat *font_format;
70 int nrealized;
71 BOOL *realized;
72 void **bitmaps;
73 XGlyphInfo *gis;
74 } gsCacheEntryFormat;
75
76 typedef struct
77 {
78 LFANDSIZE lfsz;
79 AA_Type aa_default;
80 gsCacheEntryFormat * format[AA_MAXVALUE];
81 INT count;
82 INT next;
83 } gsCacheEntry;
84
85 struct tagXRENDERINFO
86 {
87 int cache_index;
88 Picture pict;
89 };
90
91
92 static gsCacheEntry *glyphsetCache = NULL;
93 static DWORD glyphsetCacheSize = 0;
94 static INT lastfree = -1;
95 static INT mru = -1;
96
97 #define INIT_CACHE_SIZE 10
98
99 static int antialias = 1;
100
101 static void *xrender_handle;
102
103 #define MAKE_FUNCPTR(f) static typeof(f) * p##f;
104 MAKE_FUNCPTR(XRenderAddGlyphs)
105 MAKE_FUNCPTR(XRenderComposite)
106 MAKE_FUNCPTR(XRenderCompositeString8)
107 MAKE_FUNCPTR(XRenderCompositeString16)
108 MAKE_FUNCPTR(XRenderCompositeString32)
109 MAKE_FUNCPTR(XRenderCompositeText16)
110 MAKE_FUNCPTR(XRenderCreateGlyphSet)
111 MAKE_FUNCPTR(XRenderCreatePicture)
112 MAKE_FUNCPTR(XRenderFillRectangle)
113 MAKE_FUNCPTR(XRenderFindFormat)
114 MAKE_FUNCPTR(XRenderFindVisualFormat)
115 MAKE_FUNCPTR(XRenderFreeGlyphSet)
116 MAKE_FUNCPTR(XRenderFreePicture)
117 MAKE_FUNCPTR(XRenderSetPictureClipRectangles)
118 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
119 MAKE_FUNCPTR(XRenderSetPictureTransform)
120 #endif
121 MAKE_FUNCPTR(XRenderQueryExtension)
122 #undef MAKE_FUNCPTR
123
124 static CRITICAL_SECTION xrender_cs;
125 static CRITICAL_SECTION_DEBUG critsect_debug =
126 {
127 0, 0, &xrender_cs,
128 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
129 0, 0, { (DWORD_PTR)(__FILE__ ": xrender_cs") }
130 };
131 static CRITICAL_SECTION xrender_cs = { &critsect_debug, -1, 0, 0, 0, 0 };
132
133 #define MS_MAKE_TAG( _x1, _x2, _x3, _x4 ) \
134 ( ( (ULONG)_x4 << 24 ) | \
135 ( (ULONG)_x3 << 16 ) | \
136 ( (ULONG)_x2 << 8 ) | \
137 (ULONG)_x1 )
138
139 #define MS_GASP_TAG MS_MAKE_TAG('g', 'a', 's', 'p')
140
141 #define GASP_GRIDFIT 0x01
142 #define GASP_DOGRAY 0x02
143
144 #ifdef WORDS_BIGENDIAN
145 #define get_be_word(x) (x)
146 #define NATIVE_BYTE_ORDER MSBFirst
147 #else
148 #define get_be_word(x) RtlUshortByteSwap(x)
149 #define NATIVE_BYTE_ORDER LSBFirst
150 #endif
151
152 /***********************************************************************
153 * X11DRV_XRender_Init
154 *
155 * Let's see if our XServer has the extension available
156 *
157 */
158 void X11DRV_XRender_Init(void)
159 {
160 int event_base, i;
161 XRenderPictFormat pf;
162
163 if (client_side_with_render &&
164 wine_dlopen(SONAME_LIBX11, RTLD_NOW|RTLD_GLOBAL, NULL, 0) &&
165 wine_dlopen(SONAME_LIBXEXT, RTLD_NOW|RTLD_GLOBAL, NULL, 0) &&
166 (xrender_handle = wine_dlopen(SONAME_LIBXRENDER, RTLD_NOW, NULL, 0)))
167 {
168
169 #define LOAD_FUNCPTR(f) if((p##f = wine_dlsym(xrender_handle, #f, NULL, 0)) == NULL) goto sym_not_found;
170 LOAD_FUNCPTR(XRenderAddGlyphs)
171 LOAD_FUNCPTR(XRenderComposite)
172 LOAD_FUNCPTR(XRenderCompositeString8)
173 LOAD_FUNCPTR(XRenderCompositeString16)
174 LOAD_FUNCPTR(XRenderCompositeString32)
175 LOAD_FUNCPTR(XRenderCompositeText16)
176 LOAD_FUNCPTR(XRenderCreateGlyphSet)
177 LOAD_FUNCPTR(XRenderCreatePicture)
178 LOAD_FUNCPTR(XRenderFillRectangle)
179 LOAD_FUNCPTR(XRenderFindFormat)
180 LOAD_FUNCPTR(XRenderFindVisualFormat)
181 LOAD_FUNCPTR(XRenderFreeGlyphSet)
182 LOAD_FUNCPTR(XRenderFreePicture)
183 LOAD_FUNCPTR(XRenderSetPictureClipRectangles)
184 LOAD_FUNCPTR(XRenderQueryExtension)
185 #undef LOAD_FUNCPTR
186 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
187 #define LOAD_OPTIONAL_FUNCPTR(f) p##f = wine_dlsym(xrender_handle, #f, NULL, 0);
188 LOAD_OPTIONAL_FUNCPTR(XRenderSetPictureTransform)
189 #undef LOAD_OPTIONAL_FUNCPTR
190 #endif
191
192
193 wine_tsx11_lock();
194 if(pXRenderQueryExtension(gdi_display, &event_base, &xrender_error_base)) {
195 X11DRV_XRender_Installed = TRUE;
196 TRACE("Xrender is up and running error_base = %d\n", xrender_error_base);
197 pict_formats[color_drawable] = pXRenderFindVisualFormat(gdi_display, visual);
198 if(!pict_formats[color_drawable])
199 {
200 /* Xrender doesn't like DirectColor visuals, try to find a TrueColor one instead */
201 if (visual->class == DirectColor)
202 {
203 XVisualInfo info;
204 if (XMatchVisualInfo( gdi_display, DefaultScreen(gdi_display),
205 screen_depth, TrueColor, &info ))
206 {
207 pict_formats[color_drawable] = pXRenderFindVisualFormat(gdi_display, info.visual);
208 if (pict_formats[color_drawable]) visual = info.visual;
209 }
210 }
211 }
212 if(!pict_formats[color_drawable]) /* This fails in buggy versions of libXrender.so */
213 {
214 wine_tsx11_unlock();
215 WINE_MESSAGE(
216 "Wine has detected that you probably have a buggy version\n"
217 "of libXrender.so . Because of this client side font rendering\n"
218 "will be disabled. Please upgrade this library.\n");
219 X11DRV_XRender_Installed = FALSE;
220 return;
221 }
222 pf.type = PictTypeDirect;
223 pf.depth = 1;
224 pf.direct.alpha = 0;
225 pf.direct.alphaMask = 1;
226 pict_formats[mono_drawable] = pXRenderFindFormat(gdi_display, PictFormatType |
227 PictFormatDepth | PictFormatAlpha |
228 PictFormatAlphaMask, &pf, 0);
229 if(!pict_formats[mono_drawable]) {
230 ERR("mono_format == NULL?\n");
231 X11DRV_XRender_Installed = FALSE;
232 }
233 if (!visual->red_mask || !visual->green_mask || !visual->blue_mask) {
234 WARN("one or more of the colour masks are 0, disabling XRENDER. Try running in 16-bit mode or higher.\n");
235 X11DRV_XRender_Installed = FALSE;
236 }
237 }
238 wine_tsx11_unlock();
239 }
240
241 sym_not_found:
242 if(X11DRV_XRender_Installed || client_side_with_core)
243 {
244 glyphsetCache = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
245 sizeof(*glyphsetCache) * INIT_CACHE_SIZE);
246
247 glyphsetCacheSize = INIT_CACHE_SIZE;
248 lastfree = 0;
249 for(i = 0; i < INIT_CACHE_SIZE; i++) {
250 glyphsetCache[i].next = i + 1;
251 glyphsetCache[i].count = -1;
252 }
253 glyphsetCache[i-1].next = -1;
254 using_client_side_fonts = 1;
255
256 if(!X11DRV_XRender_Installed) {
257 TRACE("Xrender is not available on your XServer, client side rendering with the core protocol instead.\n");
258 if(screen_depth <= 8 || !client_side_antialias_with_core)
259 antialias = 0;
260 } else {
261 if(screen_depth <= 8 || !client_side_antialias_with_render)
262 antialias = 0;
263 }
264 }
265 else TRACE("Using X11 core fonts\n");
266 }
267
268 static BOOL fontcmp(LFANDSIZE *p1, LFANDSIZE *p2)
269 {
270 if(p1->hash != p2->hash) return TRUE;
271 if(memcmp(&p1->devsize, &p2->devsize, sizeof(p1->devsize))) return TRUE;
272 if(memcmp(&p1->xform, &p2->xform, sizeof(p1->xform))) return TRUE;
273 if(memcmp(&p1->lf, &p2->lf, offsetof(LOGFONTW, lfFaceName))) return TRUE;
274 return strcmpiW(p1->lf.lfFaceName, p2->lf.lfFaceName);
275 }
276
277 #if 0
278 static void walk_cache(void)
279 {
280 int i;
281
282 EnterCriticalSection(&xrender_cs);
283 for(i=mru; i >= 0; i = glyphsetCache[i].next)
284 TRACE("item %d\n", i);
285 LeaveCriticalSection(&xrender_cs);
286 }
287 #endif
288
289 static int LookupEntry(LFANDSIZE *plfsz)
290 {
291 int i, prev_i = -1;
292
293 for(i = mru; i >= 0; i = glyphsetCache[i].next) {
294 TRACE("%d\n", i);
295 if(glyphsetCache[i].count == -1) { /* reached free list so stop */
296 i = -1;
297 break;
298 }
299
300 if(!fontcmp(&glyphsetCache[i].lfsz, plfsz)) {
301 glyphsetCache[i].count++;
302 if(prev_i >= 0) {
303 glyphsetCache[prev_i].next = glyphsetCache[i].next;
304 glyphsetCache[i].next = mru;
305 mru = i;
306 }
307 TRACE("found font in cache %d\n", i);
308 return i;
309 }
310 prev_i = i;
311 }
312 TRACE("font not in cache\n");
313 return -1;
314 }
315
316 static void FreeEntry(int entry)
317 {
318 int i, format;
319
320 for(format = 0; format < AA_MAXVALUE; format++) {
321 gsCacheEntryFormat * formatEntry;
322
323 if( !glyphsetCache[entry].format[format] )
324 continue;
325
326 formatEntry = glyphsetCache[entry].format[format];
327
328 if(formatEntry->glyphset) {
329 wine_tsx11_lock();
330 pXRenderFreeGlyphSet(gdi_display, formatEntry->glyphset);
331 wine_tsx11_unlock();
332 formatEntry->glyphset = 0;
333 }
334 if(formatEntry->nrealized) {
335 HeapFree(GetProcessHeap(), 0, formatEntry->realized);
336 formatEntry->realized = NULL;
337 if(formatEntry->bitmaps) {
338 for(i = 0; i < formatEntry->nrealized; i++)
339 HeapFree(GetProcessHeap(), 0, formatEntry->bitmaps[i]);
340 HeapFree(GetProcessHeap(), 0, formatEntry->bitmaps);
341 formatEntry->bitmaps = NULL;
342 }
343 HeapFree(GetProcessHeap(), 0, formatEntry->gis);
344 formatEntry->gis = NULL;
345 formatEntry->nrealized = 0;
346 }
347
348 HeapFree(GetProcessHeap(), 0, formatEntry);
349 glyphsetCache[entry].format[format] = NULL;
350 }
351 }
352
353 static int AllocEntry(void)
354 {
355 int best = -1, prev_best = -1, i, prev_i = -1;
356
357 if(lastfree >= 0) {
358 assert(glyphsetCache[lastfree].count == -1);
359 glyphsetCache[lastfree].count = 1;
360 best = lastfree;
361 lastfree = glyphsetCache[lastfree].next;
362 assert(best != mru);
363 glyphsetCache[best].next = mru;
364 mru = best;
365
366 TRACE("empty space at %d, next lastfree = %d\n", mru, lastfree);
367 return mru;
368 }
369
370 for(i = mru; i >= 0; i = glyphsetCache[i].next) {
371 if(glyphsetCache[i].count == 0) {
372 best = i;
373 prev_best = prev_i;
374 }
375 prev_i = i;
376 }
377
378 if(best >= 0) {
379 TRACE("freeing unused glyphset at cache %d\n", best);
380 FreeEntry(best);
381 glyphsetCache[best].count = 1;
382 if(prev_best >= 0) {
383 glyphsetCache[prev_best].next = glyphsetCache[best].next;
384 glyphsetCache[best].next = mru;
385 mru = best;
386 } else {
387 assert(mru == best);
388 }
389 return mru;
390 }
391
392 TRACE("Growing cache\n");
393
394 if (glyphsetCache)
395 glyphsetCache = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
396 glyphsetCache,
397 (glyphsetCacheSize + INIT_CACHE_SIZE)
398 * sizeof(*glyphsetCache));
399 else
400 glyphsetCache = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
401 (glyphsetCacheSize + INIT_CACHE_SIZE)
402 * sizeof(*glyphsetCache));
403
404 for(best = i = glyphsetCacheSize; i < glyphsetCacheSize + INIT_CACHE_SIZE;
405 i++) {
406 glyphsetCache[i].next = i + 1;
407 glyphsetCache[i].count = -1;
408 }
409 glyphsetCache[i-1].next = -1;
410 glyphsetCacheSize += INIT_CACHE_SIZE;
411
412 lastfree = glyphsetCache[best].next;
413 glyphsetCache[best].count = 1;
414 glyphsetCache[best].next = mru;
415 mru = best;
416 TRACE("new free cache slot at %d\n", mru);
417 return mru;
418 }
419
420 static BOOL get_gasp_flags(X11DRV_PDEVICE *physDev, WORD *flags)
421 {
422 DWORD size;
423 WORD *gasp, *buffer;
424 WORD num_recs;
425 DWORD ppem;
426 TEXTMETRICW tm;
427
428 *flags = 0;
429
430 size = GetFontData(physDev->hdc, MS_GASP_TAG, 0, NULL, 0);
431 if(size == GDI_ERROR)
432 return FALSE;
433
434 gasp = buffer = HeapAlloc(GetProcessHeap(), 0, size);
435 GetFontData(physDev->hdc, MS_GASP_TAG, 0, gasp, size);
436
437 GetTextMetricsW(physDev->hdc, &tm);
438 ppem = abs(X11DRV_YWStoDS(physDev, tm.tmAscent + tm.tmDescent - tm.tmInternalLeading));
439
440 gasp++;
441 num_recs = get_be_word(*gasp);
442 gasp++;
443 while(num_recs--)
444 {
445 *flags = get_be_word(*(gasp + 1));
446 if(ppem <= get_be_word(*gasp))
447 break;
448 gasp += 2;
449 }
450 TRACE("got flags %04x for ppem %d\n", *flags, ppem);
451
452 HeapFree(GetProcessHeap(), 0, buffer);
453 return TRUE;
454 }
455
456 static AA_Type get_antialias_type( X11DRV_PDEVICE *physDev, BOOL subpixel, BOOL hinter)
457 {
458 AA_Type ret;
459 WORD flags;
460 UINT font_smoothing_type, font_smoothing_orientation;
461
462 if (X11DRV_XRender_Installed && subpixel &&
463 SystemParametersInfoW( SPI_GETFONTSMOOTHINGTYPE, 0, &font_smoothing_type, 0) &&
464 font_smoothing_type == FE_FONTSMOOTHINGCLEARTYPE)
465 {
466 if ( SystemParametersInfoW( SPI_GETFONTSMOOTHINGORIENTATION, 0,
467 &font_smoothing_orientation, 0) &&
468 font_smoothing_orientation == FE_FONTSMOOTHINGORIENTATIONBGR)
469 {
470 ret = AA_BGR;
471 }
472 else
473 ret = AA_RGB;
474 /*FIXME
475 If the monitor is in portrait mode, ClearType is disabled in the MS Windows (MSDN).
476 But, Wine's subpixel rendering can support the portrait mode.
477 */
478 }
479 else if (!hinter || !get_gasp_flags(physDev, &flags) || flags & GASP_DOGRAY)
480 ret = AA_Grey;
481 else
482 ret = AA_None;
483
484 return ret;
485 }
486
487 static int GetCacheEntry(X11DRV_PDEVICE *physDev, LFANDSIZE *plfsz)
488 {
489 int ret;
490 int format;
491 gsCacheEntry *entry;
492 static int hinter = -1;
493 static int subpixel = -1;
494 BOOL font_smoothing;
495
496 if((ret = LookupEntry(plfsz)) != -1) return ret;
497
498 ret = AllocEntry();
499 entry = glyphsetCache + ret;
500 entry->lfsz = *plfsz;
501 for( format = 0; format < AA_MAXVALUE; format++ ) {
502 assert( !entry->format[format] );
503 }
504
505 if(antialias && plfsz->lf.lfQuality != NONANTIALIASED_QUALITY)
506 {
507 if(hinter == -1 || subpixel == -1)
508 {
509 RASTERIZER_STATUS status;
510 GetRasterizerCaps(&status, sizeof(status));
511 hinter = status.wFlags & WINE_TT_HINTER_ENABLED;
512 subpixel = status.wFlags & WINE_TT_SUBPIXEL_RENDERING_ENABLED;
513 }
514
515 switch (plfsz->lf.lfQuality)
516 {
517 case ANTIALIASED_QUALITY:
518 entry->aa_default = get_antialias_type( physDev, FALSE, hinter );
519 break;
520 case CLEARTYPE_QUALITY:
521 case CLEARTYPE_NATURAL_QUALITY:
522 entry->aa_default = get_antialias_type( physDev, subpixel, hinter );
523 break;
524 case DEFAULT_QUALITY:
525 case DRAFT_QUALITY:
526 case PROOF_QUALITY:
527 default:
528 if ( SystemParametersInfoW( SPI_GETFONTSMOOTHING, 0, &font_smoothing, 0) &&
529 font_smoothing)
530 {
531 entry->aa_default = get_antialias_type( physDev, subpixel, hinter );
532 }
533 else
534 entry->aa_default = AA_None;
535 break;
536 }
537 }
538 else
539 entry->aa_default = AA_None;
540
541 return ret;
542 }
543
544 static void dec_ref_cache(int index)
545 {
546 assert(index >= 0);
547 TRACE("dec'ing entry %d to %d\n", index, glyphsetCache[index].count - 1);
548 assert(glyphsetCache[index].count > 0);
549 glyphsetCache[index].count--;
550 }
551
552 static void lfsz_calc_hash(LFANDSIZE *plfsz)
553 {
554 DWORD hash = 0, *ptr, two_chars;
555 WORD *pwc;
556 int i;
557
558 hash ^= plfsz->devsize.cx;
559 hash ^= plfsz->devsize.cy;
560 for(i = 0, ptr = (DWORD*)&plfsz->xform; i < sizeof(XFORM)/sizeof(DWORD); i++, ptr++)
561 hash ^= *ptr;
562 for(i = 0, ptr = (DWORD*)&plfsz->lf; i < 7; i++, ptr++)
563 hash ^= *ptr;
564 for(i = 0, ptr = (DWORD*)plfsz->lf.lfFaceName; i < LF_FACESIZE/2; i++, ptr++) {
565 two_chars = *ptr;
566 pwc = (WCHAR *)&two_chars;
567 if(!*pwc) break;
568 *pwc = toupperW(*pwc);
569 pwc++;
570 *pwc = toupperW(*pwc);
571 hash ^= two_chars;
572 if(!*pwc) break;
573 }
574 plfsz->hash = hash;
575 return;
576 }
577
578 /***********************************************************************
579 * X11DRV_XRender_Finalize
580 */
581 void X11DRV_XRender_Finalize(void)
582 {
583 int i;
584
585 EnterCriticalSection(&xrender_cs);
586 for(i = mru; i >= 0; i = glyphsetCache[i].next)
587 FreeEntry(i);
588 LeaveCriticalSection(&xrender_cs);
589 }
590
591
592 /***********************************************************************
593 * X11DRV_XRender_SelectFont
594 */
595 BOOL X11DRV_XRender_SelectFont(X11DRV_PDEVICE *physDev, HFONT hfont)
596 {
597 LFANDSIZE lfsz;
598
599 GetObjectW(hfont, sizeof(lfsz.lf), &lfsz.lf);
600 TRACE("h=%d w=%d weight=%d it=%d charset=%d name=%s\n",
601 lfsz.lf.lfHeight, lfsz.lf.lfWidth, lfsz.lf.lfWeight,
602 lfsz.lf.lfItalic, lfsz.lf.lfCharSet, debugstr_w(lfsz.lf.lfFaceName));
603 lfsz.lf.lfWidth = abs( lfsz.lf.lfWidth );
604 lfsz.devsize.cx = X11DRV_XWStoDS( physDev, lfsz.lf.lfWidth );
605 lfsz.devsize.cy = X11DRV_YWStoDS( physDev, lfsz.lf.lfHeight );
606 GetWorldTransform( physDev->hdc, &lfsz.xform );
607 lfsz_calc_hash(&lfsz);
608
609 EnterCriticalSection(&xrender_cs);
610 if(!physDev->xrender) {
611 physDev->xrender = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
612 sizeof(*physDev->xrender));
613 physDev->xrender->cache_index = -1;
614 }
615 else if(physDev->xrender->cache_index != -1)
616 dec_ref_cache(physDev->xrender->cache_index);
617 physDev->xrender->cache_index = GetCacheEntry(physDev, &lfsz);
618 LeaveCriticalSection(&xrender_cs);
619 return 0;
620 }
621
622 /***********************************************************************
623 * X11DRV_XRender_DeleteDC
624 */
625 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE *physDev)
626 {
627 X11DRV_XRender_UpdateDrawable(physDev);
628
629 EnterCriticalSection(&xrender_cs);
630 if(physDev->xrender->cache_index != -1)
631 dec_ref_cache(physDev->xrender->cache_index);
632 LeaveCriticalSection(&xrender_cs);
633
634 HeapFree(GetProcessHeap(), 0, physDev->xrender);
635 physDev->xrender = NULL;
636 return;
637 }
638
639 /***********************************************************************
640 * X11DRV_XRender_UpdateDrawable
641 *
642 * This gets called from X11DRV_SetDrawable and X11DRV_SelectBitmap.
643 * It deletes the pict and tile when the drawable changes.
644 */
645 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE *physDev)
646 {
647 wine_tsx11_lock();
648
649 if(physDev->xrender->pict)
650 {
651 TRACE("freeing pict = %lx dc = %p\n", physDev->xrender->pict, physDev->hdc);
652 XFlush(gdi_display);
653 pXRenderFreePicture(gdi_display, physDev->xrender->pict);
654 physDev->xrender->pict = 0;
655 }
656 wine_tsx11_unlock();
657
658 return;
659 }
660
661 /************************************************************************
662 * UploadGlyph
663 *
664 * Helper to ExtTextOut. Must be called inside xrender_cs
665 */
666 static BOOL UploadGlyph(X11DRV_PDEVICE *physDev, int glyph, AA_Type format)
667 {
668 unsigned int buflen;
669 char *buf;
670 Glyph gid;
671 GLYPHMETRICS gm;
672 XGlyphInfo gi;
673 gsCacheEntry *entry = glyphsetCache + physDev->xrender->cache_index;
674 gsCacheEntryFormat *formatEntry;
675 UINT ggo_format = GGO_GLYPH_INDEX;
676 XRenderPictFormat pf;
677 unsigned long pf_mask;
678 static const char zero[4];
679 static const MAT2 identity = { {0,1},{0,0},{0,0},{0,1} };
680
681 switch(format) {
682 case AA_Grey:
683 ggo_format |= WINE_GGO_GRAY16_BITMAP;
684 break;
685 case AA_RGB:
686 ggo_format |= WINE_GGO_HRGB_BITMAP;
687 break;
688 case AA_BGR:
689 ggo_format |= WINE_GGO_HBGR_BITMAP;
690 break;
691 case AA_VRGB:
692 ggo_format |= WINE_GGO_VRGB_BITMAP;
693 break;
694 case AA_VBGR:
695 ggo_format |= WINE_GGO_VBGR_BITMAP;
696 break;
697
698 default:
699 ERR("aa = %d - not implemented\n", format);
700 case AA_None:
701 ggo_format |= GGO_BITMAP;
702 break;
703 }
704
705 buflen = GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, 0, NULL, &identity);
706 if(buflen == GDI_ERROR) {
707 if(format != AA_None) {
708 format = AA_None;
709 entry->aa_default = AA_None;
710 ggo_format = GGO_GLYPH_INDEX | GGO_BITMAP;
711 buflen = GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, 0, NULL, &identity);
712 }
713 if(buflen == GDI_ERROR) {
714 WARN("GetGlyphOutlineW failed\n");
715 return FALSE;
716 }
717 TRACE("Turning off antialiasing for this monochrome font\n");
718 }
719
720 /* If there is nothing for the current type, we create the entry. */
721 if( !entry->format[format] ) {
722 entry->format[format] = HeapAlloc(GetProcessHeap(),
723 HEAP_ZERO_MEMORY,
724 sizeof(gsCacheEntryFormat));
725 }
726 formatEntry = entry->format[format];
727
728 if(formatEntry->nrealized <= glyph) {
729 formatEntry->nrealized = (glyph / 128 + 1) * 128;
730
731 if (formatEntry->realized)
732 formatEntry->realized = HeapReAlloc(GetProcessHeap(),
733 HEAP_ZERO_MEMORY,
734 formatEntry->realized,
735 formatEntry->nrealized * sizeof(BOOL));
736 else
737 formatEntry->realized = HeapAlloc(GetProcessHeap(),
738 HEAP_ZERO_MEMORY,
739 formatEntry->nrealized * sizeof(BOOL));
740
741 if(!X11DRV_XRender_Installed) {
742 if (formatEntry->bitmaps)
743 formatEntry->bitmaps = HeapReAlloc(GetProcessHeap(),
744 HEAP_ZERO_MEMORY,
745 formatEntry->bitmaps,
746 formatEntry->nrealized * sizeof(formatEntry->bitmaps[0]));
747 else
748 formatEntry->bitmaps = HeapAlloc(GetProcessHeap(),
749 HEAP_ZERO_MEMORY,
750 formatEntry->nrealized * sizeof(formatEntry->bitmaps[0]));
751 }
752 if (formatEntry->gis)
753 formatEntry->gis = HeapReAlloc(GetProcessHeap(),
754 HEAP_ZERO_MEMORY,
755 formatEntry->gis,
756 formatEntry->nrealized * sizeof(formatEntry->gis[0]));
757 else
758 formatEntry->gis = HeapAlloc(GetProcessHeap(),
759 HEAP_ZERO_MEMORY,
760 formatEntry->nrealized * sizeof(formatEntry->gis[0]));
761 }
762
763
764 if(formatEntry->glyphset == 0 && X11DRV_XRender_Installed) {
765 switch(format) {
766 case AA_Grey:
767 pf_mask = PictFormatType | PictFormatDepth | PictFormatAlpha | PictFormatAlphaMask,
768 pf.type = PictTypeDirect;
769 pf.depth = 8;
770 pf.direct.alpha = 0;
771 pf.direct.alphaMask = 0xff;
772 break;
773
774 case AA_RGB:
775 case AA_BGR:
776 case AA_VRGB:
777 case AA_VBGR:
778 pf_mask = PictFormatType | PictFormatDepth | PictFormatRed | PictFormatRedMask |
779 PictFormatGreen | PictFormatGreenMask | PictFormatBlue |
780 PictFormatBlueMask | PictFormatAlpha | PictFormatAlphaMask;
781 pf.type = PictTypeDirect;
782 pf.depth = 32;
783 pf.direct.red = 16;
784 pf.direct.redMask = 0xff;
785 pf.direct.green = 8;
786 pf.direct.greenMask = 0xff;
787 pf.direct.blue = 0;
788 pf.direct.blueMask = 0xff;
789 pf.direct.alpha = 24;
790 pf.direct.alphaMask = 0xff;
791 break;
792
793 default:
794 ERR("aa = %d - not implemented\n", format);
795 case AA_None:
796 pf_mask = PictFormatType | PictFormatDepth | PictFormatAlpha | PictFormatAlphaMask,
797 pf.type = PictTypeDirect;
798 pf.depth = 1;
799 pf.direct.alpha = 0;
800 pf.direct.alphaMask = 1;
801 break;
802 }
803
804 wine_tsx11_lock();
805 formatEntry->font_format = pXRenderFindFormat(gdi_display, pf_mask, &pf, 0);
806 formatEntry->glyphset = pXRenderCreateGlyphSet(gdi_display, formatEntry->font_format);
807 wine_tsx11_unlock();
808 }
809
810
811 buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, buflen);
812 GetGlyphOutlineW(physDev->hdc, glyph, ggo_format, &gm, buflen, buf, &identity);
813 formatEntry->realized[glyph] = TRUE;
814
815 TRACE("buflen = %d. Got metrics: %dx%d adv=%d,%d origin=%d,%d\n",
816 buflen,
817 gm.gmBlackBoxX, gm.gmBlackBoxY, gm.gmCellIncX, gm.gmCellIncY,
818 gm.gmptGlyphOrigin.x, gm.gmptGlyphOrigin.y);
819
820 gi.width = gm.gmBlackBoxX;
821 gi.height = gm.gmBlackBoxY;
822 gi.x = -gm.gmptGlyphOrigin.x;
823 gi.y = gm.gmptGlyphOrigin.y;
824 gi.xOff = gm.gmCellIncX;
825 gi.yOff = gm.gmCellIncY;
826
827 if(TRACE_ON(xrender)) {
828 int pitch, i, j;
829 char output[300];
830 unsigned char *line;
831
832 if(format == AA_None) {
833 pitch = ((gi.width + 31) / 32) * 4;
834 for(i = 0; i < gi.height; i++) {
835 line = (unsigned char*) buf + i * pitch;
836 output[0] = '\0';
837 for(j = 0; j < pitch * 8; j++) {
838 strcat(output, (line[j / 8] & (1 << (7 - (j % 8)))) ? "#" : " ");
839 }
840 TRACE("%s\n", output);
841 }
842 } else {
843 static const char blks[] = " .:;!o*#";
844 char str[2];
845
846 str[1] = '\0';
847 pitch = ((gi.width + 3) / 4) * 4;
848 for(i = 0; i < gi.height; i++) {
849 line = (unsigned char*) buf + i * pitch;
850 output[0] = '\0';
851 for(j = 0; j < pitch; j++) {
852 str[0] = blks[line[j] >> 5];
853 strcat(output, str);
854 }
855 TRACE("%s\n", output);
856 }
857 }
858 }
859
860
861 if(formatEntry->glyphset) {
862 if(format == AA_None && BitmapBitOrder(gdi_display) != MSBFirst) {
863 unsigned char *byte = (unsigned char*) buf, c;
864 int i = buflen;
865
866 while(i--) {
867 c = *byte;
868
869 /* magic to flip bit order */
870 c = ((c << 1) & 0xaa) | ((c >> 1) & 0x55);
871 c = ((c << 2) & 0xcc) | ((c >> 2) & 0x33);
872 c = ((c << 4) & 0xf0) | ((c >> 4) & 0x0f);
873
874 *byte++ = c;
875 }
876 }
877 else if ( format != AA_Grey &&
878 ImageByteOrder (gdi_display) != NATIVE_BYTE_ORDER)
879 {
880 unsigned int i, *data = (unsigned int *)buf;
881 for (i = buflen / sizeof(int); i; i--, data++) *data = RtlUlongByteSwap(*data);
882 }
883 gid = glyph;
884
885 /*
886 XRenderCompositeText seems to ignore 0x0 glyphs when
887 AA_None, which means we lose the advance width of glyphs
888 like the space. We'll pretend that such glyphs are 1x1
889 bitmaps.
890 */
891
892 if(buflen == 0)
893 gi.width = gi.height = 1;
894
895 wine_tsx11_lock();
896 pXRenderAddGlyphs(gdi_display, formatEntry->glyphset, &gid, &gi, 1,
897 buflen ? buf : zero, buflen ? buflen : sizeof(zero));
898 wine_tsx11_unlock();
899 HeapFree(GetProcessHeap(), 0, buf);
900 } else {
901 formatEntry->bitmaps[glyph] = buf;
902 }
903
904 formatEntry->gis[glyph] = gi;
905
906 return TRUE;
907 }
908
909 static void SharpGlyphMono(X11DRV_PDEVICE *physDev, INT x, INT y,
910 void *bitmap, XGlyphInfo *gi)
911 {
912 unsigned char *srcLine = bitmap, *src;
913 unsigned char bits, bitsMask;
914 int width = gi->width;
915 int stride = ((width + 31) & ~31) >> 3;
916 int height = gi->height;
917 int w;
918 int xspan, lenspan;
919
920 TRACE("%d, %d\n", x, y);
921 x -= gi->x;
922 y -= gi->y;
923 while (height--)
924 {
925 src = srcLine;
926 srcLine += stride;
927 w = width;
928
929 bitsMask = 0x80; /* FreeType is always MSB first */
930 bits = *src++;
931
932 xspan = x;
933 while (w)
934 {
935 if (bits & bitsMask)
936 {
937 lenspan = 0;
938 do
939 {
940 lenspan++;
941 if (lenspan == w)
942 break;
943 bitsMask = bitsMask >> 1;
944 if (!bitsMask)
945 {
946 bits = *src++;
947 bitsMask = 0x80;
948 }
949 } while (bits & bitsMask);
950 XFillRectangle (gdi_display, physDev->drawable,
951 physDev->gc, xspan, y, lenspan, 1);
952 xspan += lenspan;
953 w -= lenspan;
954 }
955 else
956 {
957 do
958 {
959 w--;
960 xspan++;
961 if (!w)
962 break;
963 bitsMask = bitsMask >> 1;
964 if (!bitsMask)
965 {
966 bits = *src++;
967 bitsMask = 0x80;
968 }
969 } while (!(bits & bitsMask));
970 }
971 }
972 y++;
973 }
974 }
975
976 static void SharpGlyphGray(X11DRV_PDEVICE *physDev, INT x, INT y,
977 void *bitmap, XGlyphInfo *gi)
978 {
979 unsigned char *srcLine = bitmap, *src, bits;
980 int width = gi->width;
981 int stride = ((width + 3) & ~3);
982 int height = gi->height;
983 int w;
984 int xspan, lenspan;
985
986 x -= gi->x;
987 y -= gi->y;
988 while (height--)
989 {
990 src = srcLine;
991 srcLine += stride;
992 w = width;
993
994 bits = *src++;
995 xspan = x;
996 while (w)
997 {
998 if (bits >= 0x80)
999 {
1000 lenspan = 0;
1001 do
1002 {
1003 lenspan++;
1004 if (lenspan == w)
1005 break;
1006 bits = *src++;
1007 } while (bits >= 0x80);
1008 XFillRectangle (gdi_display, physDev->drawable,
1009 physDev->gc, xspan, y, lenspan, 1);
1010 xspan += lenspan;
1011 w -= lenspan;
1012 }
1013 else
1014 {
1015 do
1016 {
1017 w--;
1018 xspan++;
1019 if (!w)
1020 break;
1021 bits = *src++;
1022 } while (bits < 0x80);
1023 }
1024 }
1025 y++;
1026 }
1027 }
1028
1029
1030 static void ExamineBitfield (DWORD mask, int *shift, int *len)
1031 {
1032 int s, l;
1033
1034 s = 0;
1035 while ((mask & 1) == 0)
1036 {
1037 mask >>= 1;
1038 s++;
1039 }
1040 l = 0;
1041 while ((mask & 1) == 1)
1042 {
1043 mask >>= 1;
1044 l++;
1045 }
1046 *shift = s;
1047 *len = l;
1048 }
1049
1050 static DWORD GetField (DWORD pixel, int shift, int len)
1051 {
1052 pixel = pixel & (((1 << (len)) - 1) << shift);
1053 pixel = pixel << (32 - (shift + len)) >> 24;
1054 while (len < 8)
1055 {
1056 pixel |= (pixel >> len);
1057 len <<= 1;
1058 }
1059 return pixel;
1060 }
1061
1062
1063 static DWORD PutField (DWORD pixel, int shift, int len)
1064 {
1065 shift = shift - (8 - len);
1066 if (len <= 8)
1067 pixel &= (((1 << len) - 1) << (8 - len));
1068 if (shift < 0)
1069 pixel >>= -shift;
1070 else
1071 pixel <<= shift;
1072 return pixel;
1073 }
1074
1075 static void SmoothGlyphGray(XImage *image, int x, int y, void *bitmap, XGlyphInfo *gi,
1076 int color)
1077 {
1078 int r_shift, r_len;
1079 int g_shift, g_len;
1080 int b_shift, b_len;
1081 BYTE *maskLine, *mask, m;
1082 int maskStride;
1083 DWORD pixel;
1084 int width, height;
1085 int w, tx;
1086 BYTE src_r, src_g, src_b;
1087
1088 x -= gi->x;
1089 y -= gi->y;
1090 width = gi->width;
1091 height = gi->height;
1092
1093 maskLine = bitmap;
1094 maskStride = (width + 3) & ~3;
1095
1096 ExamineBitfield (image->red_mask, &r_shift, &r_len);
1097 ExamineBitfield (image->green_mask, &g_shift, &g_len);
1098 ExamineBitfield (image->blue_mask, &b_shift, &b_len);
1099
1100 src_r = GetField(color, r_shift, r_len);
1101 src_g = GetField(color, g_shift, g_len);
1102 src_b = GetField(color, b_shift, b_len);
1103
1104 for(; height--; y++)
1105 {
1106 mask = maskLine;
1107 maskLine += maskStride;
1108 w = width;
1109 tx = x;
1110
1111 if(y < 0) continue;
1112 if(y >= image->height) break;
1113
1114 for(; w--; tx++)
1115 {
1116 if(tx >= image->width) break;
1117
1118 m = *mask++;
1119 if(tx < 0) continue;
1120
1121 if (m == 0xff)
1122 XPutPixel (image, tx, y, color);
1123 else if (m)
1124 {
1125 BYTE r, g, b;
1126
1127 pixel = XGetPixel (image, tx, y);
1128
1129 r = GetField(pixel, r_shift, r_len);
1130 r = ((BYTE)~m * (WORD)r + (BYTE)m * (WORD)src_r) >> 8;
1131 g = GetField(pixel, g_shift, g_len);
1132 g = ((BYTE)~m * (WORD)g + (BYTE)m * (WORD)src_g) >> 8;
1133 b = GetField(pixel, b_shift, b_len);
1134 b = ((BYTE)~m * (WORD)b + (BYTE)m * (WORD)src_b) >> 8;
1135
1136 pixel = (PutField (r, r_shift, r_len) |
1137 PutField (g, g_shift, g_len) |
1138 PutField (b, b_shift, b_len));
1139 XPutPixel (image, tx, y, pixel);
1140 }
1141 }
1142 }
1143 }
1144
1145 /*************************************************************
1146 * get_tile_pict
1147 *
1148 * Returns an appropriate Picture for tiling the text colour.
1149 * Call and use result within the xrender_cs
1150 */
1151 static Picture get_tile_pict(enum drawable_depth_type type, int text_pixel)
1152 {
1153 static struct
1154 {
1155 Pixmap xpm;
1156 Picture pict;
1157 int current_color;
1158 } tiles[2], *tile;
1159 XRenderColor col;
1160
1161 tile = &tiles[type];
1162
1163 if(!tile->xpm)
1164 {
1165 XRenderPictureAttributes pa;
1166
1167 wine_tsx11_lock();
1168 tile->xpm = XCreatePixmap(gdi_display, root_window, 1, 1, pict_formats[type]->depth);
1169
1170 pa.repeat = True;
1171 tile->pict = pXRenderCreatePicture(gdi_display, tile->xpm, pict_formats[type], CPRepeat, &pa);
1172 wine_tsx11_unlock();
1173
1174 /* init current_color to something different from text_pixel */
1175 tile->current_color = ~text_pixel;
1176
1177 if(type == mono_drawable)
1178 {
1179 /* for a 1bpp bitmap we always need a 1 in the tile */
1180 col.red = col.green = col.blue = 0;
1181 col.alpha = 0xffff;
1182 wine_tsx11_lock();
1183 pXRenderFillRectangle(gdi_display, PictOpSrc, tile->pict, &col, 0, 0, 1, 1);
1184 wine_tsx11_unlock();
1185 }
1186 }
1187
1188 if(text_pixel != tile->current_color && type == color_drawable)
1189 {
1190 /* Map 0 -- 0xff onto 0 -- 0xffff */
1191 int r_shift, r_len;
1192 int g_shift, g_len;
1193 int b_shift, b_len;
1194
1195 ExamineBitfield (visual->red_mask, &r_shift, &r_len );
1196 ExamineBitfield (visual->green_mask, &g_shift, &g_len);
1197 ExamineBitfield (visual->blue_mask, &b_shift, &b_len);
1198
1199 col.red = GetField(text_pixel, r_shift, r_len);
1200 col.red |= col.red << 8;
1201 col.green = GetField(text_pixel, g_shift, g_len);
1202 col.green |= col.green << 8;
1203 col.blue = GetField(text_pixel, b_shift, b_len);
1204 col.blue |= col.blue << 8;
1205 col.alpha = 0xffff;
1206
1207 wine_tsx11_lock();
1208 pXRenderFillRectangle(gdi_display, PictOpSrc, tile->pict, &col, 0, 0, 1, 1);
1209 wine_tsx11_unlock();
1210 tile->current_color = text_pixel;
1211 }
1212 return tile->pict;
1213 }
1214
1215 static int XRenderErrorHandler(Display *dpy, XErrorEvent *event, void *arg)
1216 {
1217 return 1;
1218 }
1219
1220 /***********************************************************************
1221 * X11DRV_XRender_ExtTextOut
1222 */
1223 BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags,
1224 const RECT *lprect, LPCWSTR wstr, UINT count,
1225 const INT *lpDx )
1226 {
1227 RGNDATA *data;
1228 XGCValues xgcval;
1229 gsCacheEntry *entry;
1230 gsCacheEntryFormat *formatEntry;
1231 BOOL retv = FALSE;
1232 HDC hdc = physDev->hdc;
1233 int textPixel, backgroundPixel;
1234 HRGN saved_region = 0;
1235 BOOL disable_antialias = FALSE;
1236 AA_Type aa_type = AA_None;
1237 DIBSECTION bmp;
1238 unsigned int idx;
1239 double cosEsc, sinEsc;
1240 LOGFONTW lf;
1241 enum drawable_depth_type depth_type = (physDev->depth == 1) ? mono_drawable : color_drawable;
1242 Picture tile_pict = 0;
1243
1244 /* Do we need to disable antialiasing because of palette mode? */
1245 if( !physDev->bitmap || GetObjectW( physDev->bitmap->hbitmap, sizeof(bmp), &bmp ) != sizeof(bmp) ) {
1246 TRACE("bitmap is not a DIB\n");
1247 }
1248 else if (bmp.dsBmih.biBitCount <= 8) {
1249 TRACE("Disabling antialiasing\n");
1250 disable_antialias = TRUE;
1251 }
1252
1253 xgcval.function = GXcopy;
1254 xgcval.background = physDev->backgroundPixel;
1255 xgcval.fill_style = FillSolid;
1256 wine_tsx11_lock();
1257 XChangeGC( gdi_display, physDev->gc, GCFunction | GCBackground | GCFillStyle, &xgcval );
1258 wine_tsx11_unlock();
1259
1260 X11DRV_LockDIBSection( physDev, DIB_Status_GdiMod );
1261
1262 if(physDev->depth == 1) {
1263 if((physDev->textPixel & 0xffffff) == 0) {
1264 textPixel = 0;
1265 backgroundPixel = 1;
1266 } else {
1267 textPixel = 1;
1268 backgroundPixel = 0;
1269 }
1270 } else {
1271 textPixel = physDev->textPixel;
1272 backgroundPixel = physDev->backgroundPixel;
1273 }
1274
1275 if(flags & ETO_OPAQUE)
1276 {
1277 wine_tsx11_lock();
1278 XSetForeground( gdi_display, physDev->gc, backgroundPixel );
1279 XFillRectangle( gdi_display, physDev->drawable, physDev->gc,
1280 physDev->dc_rect.left + lprect->left, physDev->dc_rect.top + lprect->top,
1281 lprect->right - lprect->left, lprect->bottom - lprect->top );
1282 wine_tsx11_unlock();
1283 }
1284
1285 if(count == 0)
1286 {
1287 retv = TRUE;
1288 goto done_unlock;
1289 }
1290
1291
1292 GetObjectW(GetCurrentObject(physDev->hdc, OBJ_FONT), sizeof(lf), &lf);
1293 if(lf.lfEscapement != 0) {
1294 cosEsc = cos(lf.lfEscapement * M_PI / 1800);
1295 sinEsc = sin(lf.lfEscapement * M_PI / 1800);
1296 } else {
1297 cosEsc = 1;
1298 sinEsc = 0;
1299 }
1300
1301 if (flags & ETO_CLIPPED)
1302 {
1303 HRGN clip_region;
1304
1305 clip_region = CreateRectRgnIndirect( lprect );
1306 /* make a copy of the current device region */
1307 saved_region = CreateRectRgn( 0, 0, 0, 0 );
1308 CombineRgn( saved_region, physDev->region, 0, RGN_COPY );
1309 X11DRV_SetDeviceClipping( physDev, saved_region, clip_region );
1310 DeleteObject( clip_region );
1311 }
1312
1313 if(X11DRV_XRender_Installed) {
1314 if(!physDev->xrender->pict) {
1315 XRenderPictureAttributes pa;
1316 pa.subwindow_mode = IncludeInferiors;
1317
1318 wine_tsx11_lock();
1319 physDev->xrender->pict = pXRenderCreatePicture(gdi_display,
1320 physDev->drawable,
1321 pict_formats[depth_type],
1322 CPSubwindowMode, &pa);
1323 wine_tsx11_unlock();
1324
1325 TRACE("allocing pict = %lx dc = %p drawable = %08lx\n",
1326 physDev->xrender->pict, hdc, physDev->drawable);
1327 } else {
1328 TRACE("using existing pict = %lx dc = %p drawable = %08lx\n",
1329 physDev->xrender->pict, hdc, physDev->drawable);
1330 }
1331
1332 if ((data = X11DRV_GetRegionData( physDev->region, 0 )))
1333 {
1334 wine_tsx11_lock();
1335 pXRenderSetPictureClipRectangles( gdi_display, physDev->xrender->pict,
1336 physDev->dc_rect.left, physDev->dc_rect.top,
1337 (XRectangle *)data->Buffer, data->rdh.nCount );
1338 wine_tsx11_unlock();
1339 HeapFree( GetProcessHeap(), 0, data );
1340 }
1341 }
1342
1343 EnterCriticalSection(&xrender_cs);
1344
1345 entry = glyphsetCache + physDev->xrender->cache_index;
1346 if( disable_antialias == FALSE )
1347 aa_type = entry->aa_default;
1348 formatEntry = entry->format[aa_type];
1349
1350 for(idx = 0; idx < count; idx++) {
1351 if( !formatEntry ) {
1352 UploadGlyph(physDev, wstr[idx], aa_type);
1353 /* re-evaluate antialias since aa_default may have changed */
1354 if( disable_antialias == FALSE )
1355 aa_type = entry->aa_default;
1356 formatEntry = entry->format[aa_type];
1357 } else if( wstr[idx] >= formatEntry->nrealized || formatEntry->realized[wstr[idx]] == FALSE) {
1358 UploadGlyph(physDev, wstr[idx], aa_type);
1359 }
1360 }
1361 if (!formatEntry)
1362 {
1363 WARN("could not upload requested glyphs\n");
1364 LeaveCriticalSection(&xrender_cs);
1365 goto done_unlock;
1366 }
1367
1368 TRACE("Writing %s at %d,%d\n", debugstr_wn(wstr,count),
1369 physDev->dc_rect.left + x, physDev->dc_rect.top + y);
1370
1371 if(X11DRV_XRender_Installed)
1372 {
1373 XGlyphElt16 *elts = HeapAlloc(GetProcessHeap(), 0, sizeof(XGlyphElt16) * count);
1374 INT offset = 0;
1375 POINT desired, current;
1376 int render_op = PictOpOver;
1377
1378 /* There's a bug in XRenderCompositeText that ignores the xDst and yDst parameters.
1379 So we pass zeros to the function and move to our starting position using the first
1380 element of the elts array. */
1381
1382 desired.x = physDev->dc_rect.left + x;
1383 desired.y = physDev->dc_rect.top + y;
1384 current.x = current.y = 0;
1385
1386 tile_pict = get_tile_pict(depth_type, physDev->textPixel);
1387
1388 /* FIXME the mapping of Text/BkColor onto 1 or 0 needs investigation.
1389 */
1390 if((depth_type == mono_drawable) && (textPixel == 0))
1391 render_op = PictOpOutReverse; /* This gives us 'black' text */
1392
1393 for(idx = 0; idx < count; idx++)
1394 {
1395 elts[idx].glyphset = formatEntry->glyphset;
1396 elts[idx].chars = wstr + idx;
1397 elts[idx].nchars = 1;
1398 elts[idx].xOff = desired.x - current.x;
1399 elts[idx].yOff = desired.y - current.y;
1400
1401 current.x += (elts[idx].xOff + formatEntry->gis[wstr[idx]].xOff);
1402 current.y += (elts[idx].yOff + formatEntry->gis[wstr[idx]].yOff);
1403
1404 if(!lpDx)
1405 {
1406 desired.x += formatEntry->gis[wstr[idx]].xOff;
1407 desired.y += formatEntry->gis[wstr[idx]].yOff;
1408 }
1409 else
1410 {
1411 offset += lpDx[idx];
1412 desired.x = physDev->dc_rect.left + x + offset * cosEsc;
1413 desired.y = physDev->dc_rect.top + y - offset * sinEsc;
1414 }
1415 }
1416 wine_tsx11_lock();
1417 pXRenderCompositeText16(gdi_display, render_op,
1418 tile_pict,
1419 physDev->xrender->pict,
1420 formatEntry->font_format,
1421 0, 0, 0, 0, elts, count);
1422 wine_tsx11_unlock();
1423 HeapFree(GetProcessHeap(), 0, elts);
1424 } else {
1425 INT offset = 0, xoff = 0, yoff = 0;
1426 wine_tsx11_lock();
1427 XSetForeground( gdi_display, physDev->gc, textPixel );
1428
1429 if(aa_type == AA_None || physDev->depth == 1)
1430 {
1431 void (* sharp_glyph_fn)(X11DRV_PDEVICE *, INT, INT, void *, XGlyphInfo *);
1432
1433 if(aa_type == AA_None)
1434 sharp_glyph_fn = SharpGlyphMono;
1435 else
1436 sharp_glyph_fn = SharpGlyphGray;
1437
1438 for(idx = 0; idx < count; idx++) {
1439 sharp_glyph_fn(physDev, physDev->dc_rect.left + x + xoff,
1440 physDev->dc_rect.top + y + yoff,
1441 formatEntry->bitmaps[wstr[idx]],
1442 &formatEntry->gis[wstr[idx]]);
1443 if(lpDx) {
1444 offset += lpDx[idx];
1445 xoff = offset * cosEsc;
1446 yoff = offset * -sinEsc;
1447 } else {
1448 xoff += formatEntry->gis[wstr[idx]].xOff;
1449 yoff += formatEntry->gis[wstr[idx]].yOff;
1450 }
1451 }
1452 } else {
1453 XImage *image;
1454 int image_x, image_y, image_off_x, image_off_y, image_w, image_h;
1455 RECT extents = {0, 0, 0, 0};
1456 POINT cur = {0, 0};
1457 int w = physDev->drawable_rect.right - physDev->drawable_rect.left;
1458 int h = physDev->drawable_rect.bottom - physDev->drawable_rect.top;
1459
1460 TRACE("drawable %dx%d\n", w, h);
1461
1462 for(idx = 0; idx < count; idx++) {
1463 if(extents.left > cur.x - formatEntry->gis[wstr[idx]].x)
1464 extents.left = cur.x - formatEntry->gis[wstr[idx]].x;
1465 if(extents.top > cur.y - formatEntry->gis[wstr[idx]].y)
1466 extents.top = cur.y - formatEntry->gis[wstr[idx]].y;
1467 if(extents.right < cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width)
1468 extents.right = cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width;
1469 if(extents.bottom < cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height)
1470 extents.bottom = cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height;
1471 if(lpDx) {
1472 offset += lpDx[idx];
1473 cur.x = offset * cosEsc;
1474 cur.y = offset * -sinEsc;
1475 } else {
1476 cur.x += formatEntry->gis[wstr[idx]].xOff;
1477 cur.y += formatEntry->gis[wstr[idx]].yOff;
1478 }
1479 }
1480 TRACE("glyph extents %d,%d - %d,%d drawable x,y %d,%d\n", extents.left, extents.top,
1481 extents.right, extents.bottom, physDev->dc_rect.left + x, physDev->dc_rect.top + y);
1482
1483 if(physDev->dc_rect.left + x + extents.left >= 0) {
1484 image_x = physDev->dc_rect.left + x + extents.left;
1485 image_off_x = 0;
1486 } else {
1487 image_x = 0;
1488 image_off_x = physDev->dc_rect.left + x + extents.left;
1489 }
1490 if(physDev->dc_rect.top + y + extents.top >= 0) {
1491 image_y = physDev->dc_rect.top + y + extents.top;
1492 image_off_y = 0;
1493 } else {
1494 image_y = 0;
1495 image_off_y = physDev->dc_rect.top + y + extents.top;
1496 }
1497 if(physDev->dc_rect.left + x + extents.right < w)
1498 image_w = physDev->dc_rect.left + x + extents.right - image_x;
1499 else
1500 image_w = w - image_x;
1501 if(physDev->dc_rect.top + y + extents.bottom < h)
1502 image_h = physDev->dc_rect.top + y + extents.bottom - image_y;
1503 else
1504 image_h = h - image_y;
1505
1506 if(image_w <= 0 || image_h <= 0) goto no_image;
1507
1508 X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
1509 image = XGetImage(gdi_display, physDev->drawable,
1510 image_x, image_y, image_w, image_h,
1511 AllPlanes, ZPixmap);
1512 X11DRV_check_error();
1513
1514 TRACE("XGetImage(%p, %x, %d, %d, %d, %d, %lx, %x) depth = %d rets %p\n",
1515 gdi_display, (int)physDev->drawable, image_x, image_y,
1516 image_w, image_h, AllPlanes, ZPixmap,
1517 physDev->depth, image);
1518 if(!image) {
1519 Pixmap xpm = XCreatePixmap(gdi_display, root_window, image_w, image_h,
1520 physDev->depth);
1521 GC gc;
1522 XGCValues gcv;
1523
1524 gcv.graphics_exposures = False;
1525 gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv);
1526 XCopyArea(gdi_display, physDev->drawable, xpm, gc, image_x, image_y,
1527 image_w, image_h, 0, 0);
1528 XFreeGC(gdi_display, gc);
1529 X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
1530 image = XGetImage(gdi_display, xpm, 0, 0, image_w, image_h, AllPlanes,
1531 ZPixmap);
1532 X11DRV_check_error();
1533 XFreePixmap(gdi_display, xpm);
1534 }
1535 if(!image) goto no_image;
1536
1537 image->red_mask = visual->red_mask;
1538 image->green_mask = visual->green_mask;
1539 image->blue_mask = visual->blue_mask;
1540
1541 offset = xoff = yoff = 0;
1542 for(idx = 0; idx < count; idx++) {
1543 SmoothGlyphGray(image, xoff + image_off_x - extents.left,
1544 yoff + image_off_y - extents.top,
1545 formatEntry->bitmaps[wstr[idx]],
1546 &formatEntry->gis[wstr[idx]],
1547 physDev->textPixel);
1548 if(lpDx) {
1549 offset += lpDx[idx];
1550 xoff = offset * cosEsc;
1551 yoff = offset * -sinEsc;
1552 } else {
1553 xoff += formatEntry->gis[wstr[idx]].xOff;
1554 yoff += formatEntry->gis[wstr[idx]].yOff;
1555 }
1556 }
1557 XPutImage(gdi_display, physDev->drawable, physDev->gc, image, 0, 0,
1558 image_x, image_y, image_w, image_h);
1559 XDestroyImage(image);
1560 }
1561 no_image:
1562 wine_tsx11_unlock();
1563 }
1564 LeaveCriticalSection(&xrender_cs);
1565
1566 if (flags & ETO_CLIPPED)
1567 {
1568 /* restore the device region */
1569 X11DRV_SetDeviceClipping( physDev, saved_region, 0 );
1570 DeleteObject( saved_region );
1571 }
1572
1573 retv = TRUE;
1574
1575 done_unlock:
1576 X11DRV_UnlockDIBSection( physDev, TRUE );
1577 return retv;
1578 }
1579
1580 /******************************************************************************
1581 * AlphaBlend (x11drv.@)
1582 */
1583 BOOL CDECL X11DRV_AlphaBlend(X11DRV_PDEVICE *devDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
1584 X11DRV_PDEVICE *devSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc,
1585 BLENDFUNCTION blendfn)
1586 {
1587 XRenderPictureAttributes pa;
1588 XRenderPictFormat *src_format;
1589 XRenderPictFormat argb32_templ = {
1590 0, /* id */
1591 PictTypeDirect, /* type */
1592 32, /* depth */
1593 { /* direct */
1594 16, /* direct.red */
1595 0xff, /* direct.redMask */
1596 8, /* direct.green */
1597 0xff, /* direct.greenMask */
1598 0, /* direct.blue */
1599 0xff, /* direct.blueMask */
1600 24, /* direct.alpha */
1601 0xff, /* direct.alphaMask */
1602 },
1603 0, /* colormap */
1604 };
1605 unsigned long argb32_templ_mask =
1606 PictFormatType |
1607 PictFormatDepth |
1608 PictFormatRed |
1609 PictFormatRedMask |
1610 PictFormatGreen |
1611 PictFormatGreenMask |
1612 PictFormatBlue |
1613 PictFormatBlueMask |
1614 PictFormatAlpha |
1615 PictFormatAlphaMask;
1616
1617 Picture dst_pict, src_pict;
1618 Pixmap xpm;
1619 DIBSECTION dib;
1620 XImage *image;
1621 GC gc;
1622 XGCValues gcv;
1623 DWORD *dstbits, *data;
1624 int y, y2;
1625 POINT pts[2];
1626 BOOL top_down = FALSE;
1627 RGNDATA *rgndata;
1628 enum drawable_depth_type dst_depth_type = (devDst->depth == 1) ? mono_drawable : color_drawable;
1629
1630 if(!X11DRV_XRender_Installed) {
1631 FIXME("Unable to AlphaBlend without Xrender\n");
1632 return FALSE;
1633 }
1634 pts[0].x = xDst;
1635 pts[0].y = yDst;
1636 pts[1].x = xDst + widthDst;
1637 pts[1].y = yDst + heightDst;
1638 LPtoDP(devDst->hdc, pts, 2);
1639 xDst = pts[0].x;
1640 yDst = pts[0].y;
1641 widthDst = pts[1].x - pts[0].x;
1642 heightDst = pts[1].y - pts[0].y;
1643
1644 pts[0].x = xSrc;
1645 pts[0].y = ySrc;
1646 pts[1].x = xSrc + widthSrc;
1647 pts[1].y = ySrc + heightSrc;
1648 LPtoDP(devSrc->hdc, pts, 2);
1649 xSrc = pts[0].x;
1650 ySrc = pts[0].y;
1651 widthSrc = pts[1].x - pts[0].x;
1652 heightSrc = pts[1].y - pts[0].y;
1653 if (!widthDst || !heightDst || !widthSrc || !heightSrc) return TRUE;
1654
1655 #ifndef HAVE_XRENDERSETPICTURETRANSFORM
1656 if(widthDst != widthSrc || heightDst != heightSrc)
1657 #else
1658 if(!pXRenderSetPictureTransform)
1659 #endif
1660 {
1661 FIXME("Unable to Stretch, XRenderSetPictureTransform is currently required\n");
1662 return FALSE;
1663 }
1664
1665 if (!devSrc->bitmap || GetObjectW( devSrc->bitmap->hbitmap, sizeof(dib), &dib ) != sizeof(dib))
1666 {
1667 static BOOL out = FALSE;
1668 if (!out)
1669 {
1670 FIXME("not a dibsection\n");
1671 out = TRUE;
1672 }
1673 return FALSE;
1674 }
1675
1676 if (xSrc < 0 || ySrc < 0 || widthSrc < 0 || heightSrc < 0 || xSrc + widthSrc > dib.dsBmih.biWidth
1677 || ySrc + heightSrc > abs(dib.dsBmih.biHeight))
1678 {
1679 WARN("Invalid src coords: (%d,%d), size %dx%d\n", xSrc, ySrc, widthSrc, heightSrc);
1680 SetLastError(ERROR_INVALID_PARAMETER);
1681 return FALSE;
1682 }
1683
1684 if ((blendfn.AlphaFormat & AC_SRC_ALPHA) && blendfn.SourceConstantAlpha != 0xff)
1685 FIXME("Ignoring SourceConstantAlpha %d for AC_SRC_ALPHA\n", blendfn.SourceConstantAlpha);
1686
1687 if(dib.dsBm.bmBitsPixel != 32) {
1688 FIXME("not a 32 bpp dibsection\n");
1689 return FALSE;
1690 }
1691 dstbits = data = HeapAlloc(GetProcessHeap(), 0, heightSrc * widthSrc * 4);
1692
1693 if(dib.dsBmih.biHeight < 0) { /* top-down dib */
1694 top_down = TRUE;
1695 dstbits += widthSrc * (heightSrc - 1);
1696 y2 = ySrc;
1697 y = y2 + heightSrc - 1;
1698 }
1699 else
1700 {
1701 y = dib.dsBmih.biHeight - ySrc - 1;
1702 y2 = y - heightSrc + 1;
1703 }
1704
1705 if (blendfn.AlphaFormat & AC_SRC_ALPHA)
1706 {
1707 for(; y >= y2; y--)
1708 {
1709 memcpy(dstbits, (char *)dib.dsBm.bmBits + y * dib.dsBm.bmWidthBytes + xSrc * 4,
1710 widthSrc * 4);
1711 dstbits += (top_down ? -1 : 1) * widthSrc;
1712 }
1713 }
1714 else
1715 {
1716 DWORD source_alpha = (DWORD)blendfn.SourceConstantAlpha << 24;
1717 int x;
1718
1719 for(; y >= y2; y--)
1720 {
1721 DWORD *srcbits = (DWORD *)((char *)dib.dsBm.bmBits + y * dib.dsBm.bmWidthBytes) + xSrc;
1722 for (x = 0; x < widthSrc; x++)
1723 {
1724 DWORD argb = *srcbits++;
1725 argb = (argb & 0xffffff) | source_alpha;
1726 *dstbits++ = argb;
1727 }
1728 if (top_down) /* we traversed the row forward so we should go back by two rows */
1729 dstbits -= 2 * widthSrc;
1730 }
1731
1732 }
1733
1734 rgndata = X11DRV_GetRegionData( devDst->region, 0 );
1735
1736 wine_tsx11_lock();
1737 image = XCreateImage(gdi_display, visual, 32, ZPixmap, 0,
1738 (char*) data, widthSrc, heightSrc, 32, widthSrc * 4);
1739
1740 /*
1741 Avoid using XRenderFindStandardFormat as older libraries don't have it
1742 src_format = pXRenderFindStandardFormat(gdi_display, PictStandardARGB32);
1743 */
1744 src_format = pXRenderFindFormat(gdi_display, argb32_templ_mask, &argb32_templ, 0);
1745
1746 TRACE("src_format %p\n", src_format);
1747
1748 pa.subwindow_mode = IncludeInferiors;
1749
1750 /* FIXME use devDst->xrender->pict ? */
1751 dst_pict = pXRenderCreatePicture(gdi_display,
1752 devDst->drawable,
1753 pict_formats[dst_depth_type],
1754 CPSubwindowMode, &pa);
1755 TRACE("dst_pict %08lx\n", dst_pict);
1756 TRACE("src_drawable = %08lx\n", devSrc->drawable);
1757 xpm = XCreatePixmap(gdi_display,
1758 root_window,
1759 widthSrc, heightSrc, 32);
1760 gcv.graphics_exposures = False;
1761 gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv);
1762 TRACE("xpm = %08lx\n", xpm);
1763 XPutImage(gdi_display, xpm, gc, image, 0, 0, 0, 0, widthSrc, heightSrc);
1764
1765 src_pict = pXRenderCreatePicture(gdi_display,
1766 xpm, src_format,
1767 CPSubwindowMode, &pa);
1768 TRACE("src_pict %08lx\n", src_pict);
1769
1770 if (rgndata)
1771 {
1772 pXRenderSetPictureClipRectangles( gdi_display, dst_pict,
1773 devDst->dc_rect.left, devDst->dc_rect.top,
1774 (XRectangle *)rgndata->Buffer,
1775 rgndata->rdh.nCount );
1776 HeapFree( GetProcessHeap(), 0, rgndata );
1777 }
1778
1779 #ifdef HAVE_XRENDERSETPICTURETRANSFORM
1780 if(widthDst != widthSrc || heightDst != heightSrc) {
1781 double xscale = widthSrc/(double)widthDst;
1782 double yscale = heightSrc/(double)heightDst;
1783 XTransform xform = {{
1784 { XDoubleToFixed(xscale), XDoubleToFixed(0), XDoubleToFixed(0) },
1785 { XDoubleToFixed(0), XDoubleToFixed(yscale), XDoubleToFixed(0) },
1786 { XDoubleToFixed(0), XDoubleToFixed(0), XDoubleToFixed(1) }
1787 }};
1788 pXRenderSetPictureTransform(gdi_display, src_pict, &xform);
1789 }
1790 #endif
1791 pXRenderComposite(gdi_display, PictOpOver, src_pict, 0, dst_pict,
1792 0, 0, 0, 0,
1793 xDst + devDst->dc_rect.left, yDst + devDst->dc_rect.top, widthDst, heightDst);
1794
1795
1796 pXRenderFreePicture(gdi_display, src_pict);
1797 XFreePixmap(gdi_display, xpm);
1798 XFreeGC(gdi_display, gc);
1799 pXRenderFreePicture(gdi_display, dst_pict);
1800 image->data = NULL;
1801 XDestroyImage(image);
1802
1803 wine_tsx11_unlock();
1804 HeapFree(GetProcessHeap(), 0, data);
1805 return TRUE;
1806 }
1807
1808 #else /* SONAME_LIBXRENDER */
1809
1810 void X11DRV_XRender_Init(void)
1811 {
1812 TRACE("XRender support not compiled in.\n");
1813 return;
1814 }
1815
1816 void X11DRV_XRender_Finalize(void)
1817 {
1818 }
1819
1820 BOOL X11DRV_XRender_SelectFont(X11DRV_PDEVICE *physDev, HFONT hfont)
1821 {
1822 assert(0);
1823 return FALSE;
1824 }
1825
1826 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE *physDev)
1827 {
1828 assert(0);
1829 return;
1830 }
1831
1832 BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags,
1833 const RECT *lprect, LPCWSTR wstr, UINT count,
1834 const INT *lpDx )
1835 {
1836 assert(0);
1837 return FALSE;
1838 }
1839
1840 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE *physDev)
1841 {
1842 assert(0);
1843 return;
1844 }
1845
1846 /******************************************************************************
1847 * AlphaBlend (x11drv.@)
1848 */
1849 BOOL X11DRV_AlphaBlend(X11DRV_PDEVICE *devDst, INT xDst, INT yDst, INT widthDst, INT heightDst,
1850 X11DRV_PDEVICE *devSrc, INT xSrc, INT ySrc, INT widthSrc, INT heightSrc,
1851 BLENDFUNCTION blendfn)
1852 {
1853 FIXME("not supported - XRENDER headers were missing at compile time\n");
1854 return FALSE;
1855 }
1856
1857 #endif /* SONAME_LIBXRENDER */
Maarten's multimedia branch