git.oblomov.eu Git - wine/blob - dlls/winex11.drv/xrender.c

   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     double cosEsc, sinEsc;
1630     LOGFONTW lf;
1631     const WineXRenderFormat *dst_format = get_xrender_format_from_color_shifts(physDev->depth, physDev->color_shifts);
1632     Picture tile_pict = 0;
1633
1634     /* Do we need to disable antialiasing because of palette mode? */
1635     if( !physDev->bitmap || GetObjectW( physDev->bitmap->hbitmap, sizeof(bmp), &bmp ) != sizeof(bmp) ) {
1636         TRACE("bitmap is not a DIB\n");
1637     }
1638     else if (bmp.dsBmih.biBitCount <= 8) {
1639         TRACE("Disabling antialiasing\n");
1640         disable_antialias = TRUE;
1641     }
1642
1643     xgcval.function = GXcopy;
1644     xgcval.background = physDev->backgroundPixel;
1645     xgcval.fill_style = FillSolid;
1646     wine_tsx11_lock();
1647     XChangeGC( gdi_display, physDev->gc, GCFunction | GCBackground | GCFillStyle, &xgcval );
1648     wine_tsx11_unlock();
1649
1650     X11DRV_LockDIBSection( physDev, DIB_Status_GdiMod );
1651
1652     if(physDev->depth == 1) {
1653         if((physDev->textPixel & 0xffffff) == 0) {
1654             textPixel = 0;
1655             backgroundPixel = 1;
1656         } else {
1657             textPixel = 1;
1658             backgroundPixel = 0;
1659         }
1660     } else {
1661         textPixel = physDev->textPixel;
1662         backgroundPixel = physDev->backgroundPixel;
1663     }
1664
1665     if(flags & ETO_OPAQUE)
1666     {
1667         wine_tsx11_lock();
1668         XSetForeground( gdi_display, physDev->gc, backgroundPixel );
1669         XFillRectangle( gdi_display, physDev->drawable, physDev->gc,
1670                         physDev->dc_rect.left + lprect->left, physDev->dc_rect.top + lprect->top,
1671                         lprect->right - lprect->left, lprect->bottom - lprect->top );
1672         wine_tsx11_unlock();
1673     }
1674
1675     if(count == 0)
1676     {
1677         retv = TRUE;
1678         goto done_unlock;
1679     }
1680
1681
1682     GetObjectW(GetCurrentObject(physDev->hdc, OBJ_FONT), sizeof(lf), &lf);
1683     if(lf.lfEscapement != 0) {
1684         cosEsc = cos(lf.lfEscapement * M_PI / 1800);
1685         sinEsc = sin(lf.lfEscapement * M_PI / 1800);
1686     } else {
1687         cosEsc = 1;
1688         sinEsc = 0;
1689     }
1690
1691     if (flags & ETO_CLIPPED)
1692     {
1693         HRGN clip_region;
1694
1695         clip_region = CreateRectRgnIndirect( lprect );
1696         /* make a copy of the current device region */
1697         saved_region = CreateRectRgn( 0, 0, 0, 0 );
1698         CombineRgn( saved_region, physDev->region, 0, RGN_COPY );
1699         X11DRV_SetDeviceClipping( physDev, saved_region, clip_region );
1700         DeleteObject( clip_region );
1701     }
1702
1703     EnterCriticalSection(&xrender_cs);
1704
1705     entry = glyphsetCache + physDev->xrender->cache_index;
1706     if( disable_antialias == FALSE )
1707         aa_type = entry->aa_default;
1708     formatEntry = entry->format[aa_type];
1709
1710     for(idx = 0; idx < count; idx++) {
1711         if( !formatEntry ) {
1712             UploadGlyph(physDev, wstr[idx], aa_type);
1713             /* re-evaluate antialias since aa_default may have changed */
1714             if( disable_antialias == FALSE )
1715                 aa_type = entry->aa_default;
1716             formatEntry = entry->format[aa_type];
1717         } else if( wstr[idx] >= formatEntry->nrealized || formatEntry->realized[wstr[idx]] == FALSE) {
1718             UploadGlyph(physDev, wstr[idx], aa_type);
1719         }
1720     }
1721     if (!formatEntry)
1722     {
1723         WARN("could not upload requested glyphs\n");
1724         LeaveCriticalSection(&xrender_cs);
1725         goto done_unlock;
1726     }
1727
1728     TRACE("Writing %s at %d,%d\n", debugstr_wn(wstr,count),
1729           physDev->dc_rect.left + x, physDev->dc_rect.top + y);
1730
1731     if(X11DRV_XRender_Installed)
1732     {
1733         XGlyphElt16 *elts = HeapAlloc(GetProcessHeap(), 0, sizeof(XGlyphElt16) * count);
1734         INT offset = 0;
1735         POINT desired, current;
1736         int render_op = PictOpOver;
1737         Picture pict = get_xrender_picture(physDev);
1738
1739         /* There's a bug in XRenderCompositeText that ignores the xDst and yDst parameters.
1740            So we pass zeros to the function and move to our starting position using the first
1741            element of the elts array. */
1742
1743         desired.x = physDev->dc_rect.left + x;
1744         desired.y = physDev->dc_rect.top + y;
1745         current.x = current.y = 0;
1746
1747         tile_pict = get_tile_pict(dst_format, physDev->textPixel);
1748
1749         /* FIXME the mapping of Text/BkColor onto 1 or 0 needs investigation.
1750          */
1751         if((dst_format->format == WXR_FORMAT_MONO) && (textPixel == 0))
1752             render_op = PictOpOutReverse; /* This gives us 'black' text */
1753
1754         for(idx = 0; idx < count; idx++)
1755         {
1756             elts[idx].glyphset = formatEntry->glyphset;
1757             elts[idx].chars = wstr + idx;
1758             elts[idx].nchars = 1;
1759             elts[idx].xOff = desired.x - current.x;
1760             elts[idx].yOff = desired.y - current.y;
1761
1762             current.x += (elts[idx].xOff + formatEntry->gis[wstr[idx]].xOff);
1763             current.y += (elts[idx].yOff + formatEntry->gis[wstr[idx]].yOff);
1764
1765             if(!lpDx)
1766             {
1767                 desired.x += formatEntry->gis[wstr[idx]].xOff;
1768                 desired.y += formatEntry->gis[wstr[idx]].yOff;
1769             }
1770             else
1771             {
1772                 offset += lpDx[idx];
1773                 desired.x = physDev->dc_rect.left + x + offset * cosEsc;
1774                 desired.y = physDev->dc_rect.top  + y - offset * sinEsc;
1775             }
1776         }
1777         wine_tsx11_lock();
1778         /* Make sure we don't have any transforms set from a previous call */
1779         set_xrender_transformation(pict, 1, 1, 0, 0);
1780         pXRenderCompositeText16(gdi_display, render_op,
1781                                 tile_pict,
1782                                 pict,
1783                                 formatEntry->font_format->pict_format,
1784                                 0, 0, 0, 0, elts, count);
1785         wine_tsx11_unlock();
1786         HeapFree(GetProcessHeap(), 0, elts);
1787     } else {
1788         INT offset = 0, xoff = 0, yoff = 0;
1789         wine_tsx11_lock();
1790         XSetForeground( gdi_display, physDev->gc, textPixel );
1791
1792         if(aa_type == AA_None || physDev->depth == 1)
1793         {
1794             void (* sharp_glyph_fn)(X11DRV_PDEVICE *, INT, INT, void *, XGlyphInfo *);
1795
1796             if(aa_type == AA_None)
1797                 sharp_glyph_fn = SharpGlyphMono;
1798             else
1799                 sharp_glyph_fn = SharpGlyphGray;
1800
1801             for(idx = 0; idx < count; idx++) {
1802                 sharp_glyph_fn(physDev, physDev->dc_rect.left + x + xoff,
1803                                physDev->dc_rect.top + y + yoff,
1804                                formatEntry->bitmaps[wstr[idx]],
1805                                &formatEntry->gis[wstr[idx]]);
1806                 if(lpDx) {
1807                     offset += lpDx[idx];
1808                     xoff = offset * cosEsc;
1809                     yoff = offset * -sinEsc;
1810                 } else {
1811                     xoff += formatEntry->gis[wstr[idx]].xOff;
1812                     yoff += formatEntry->gis[wstr[idx]].yOff;
1813                 }
1814             }
1815         } else {
1816             XImage *image;
1817             int image_x, image_y, image_off_x, image_off_y, image_w, image_h;
1818             RECT extents = {0, 0, 0, 0};
1819             POINT cur = {0, 0};
1820             int w = physDev->drawable_rect.right - physDev->drawable_rect.left;
1821             int h = physDev->drawable_rect.bottom - physDev->drawable_rect.top;
1822
1823             TRACE("drawable %dx%d\n", w, h);
1824
1825             for(idx = 0; idx < count; idx++) {
1826                 if(extents.left > cur.x - formatEntry->gis[wstr[idx]].x)
1827                     extents.left = cur.x - formatEntry->gis[wstr[idx]].x;
1828                 if(extents.top > cur.y - formatEntry->gis[wstr[idx]].y)
1829                     extents.top = cur.y - formatEntry->gis[wstr[idx]].y;
1830                 if(extents.right < cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width)
1831                     extents.right = cur.x - formatEntry->gis[wstr[idx]].x + formatEntry->gis[wstr[idx]].width;
1832                 if(extents.bottom < cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height)
1833                     extents.bottom = cur.y - formatEntry->gis[wstr[idx]].y + formatEntry->gis[wstr[idx]].height;
1834                 if(lpDx) {
1835                     offset += lpDx[idx];
1836                     cur.x = offset * cosEsc;
1837                     cur.y = offset * -sinEsc;
1838                 } else {
1839                     cur.x += formatEntry->gis[wstr[idx]].xOff;
1840                     cur.y += formatEntry->gis[wstr[idx]].yOff;
1841                 }
1842             }
1843             TRACE("glyph extents %d,%d - %d,%d drawable x,y %d,%d\n", extents.left, extents.top,
1844                   extents.right, extents.bottom, physDev->dc_rect.left + x, physDev->dc_rect.top + y);
1845
1846             if(physDev->dc_rect.left + x + extents.left >= 0) {
1847                 image_x = physDev->dc_rect.left + x + extents.left;
1848                 image_off_x = 0;
1849             } else {
1850                 image_x = 0;
1851                 image_off_x = physDev->dc_rect.left + x + extents.left;
1852             }
1853             if(physDev->dc_rect.top + y + extents.top >= 0) {
1854                 image_y = physDev->dc_rect.top + y + extents.top;
1855                 image_off_y = 0;
1856             } else {
1857                 image_y = 0;
1858                 image_off_y = physDev->dc_rect.top + y + extents.top;
1859             }
1860             if(physDev->dc_rect.left + x + extents.right < w)
1861                 image_w = physDev->dc_rect.left + x + extents.right - image_x;
1862             else
1863                 image_w = w - image_x;
1864             if(physDev->dc_rect.top + y + extents.bottom < h)
1865                 image_h = physDev->dc_rect.top + y + extents.bottom - image_y;
1866             else
1867                 image_h = h - image_y;
1868
1869             if(image_w <= 0 || image_h <= 0) goto no_image;
1870
1871             X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
1872             image = XGetImage(gdi_display, physDev->drawable,
1873                               image_x, image_y, image_w, image_h,
1874                               AllPlanes, ZPixmap);
1875             X11DRV_check_error();
1876
1877             TRACE("XGetImage(%p, %x, %d, %d, %d, %d, %lx, %x) depth = %d rets %p\n",
1878                   gdi_display, (int)physDev->drawable, image_x, image_y,
1879                   image_w, image_h, AllPlanes, ZPixmap,
1880                   physDev->depth, image);
1881             if(!image) {
1882                 Pixmap xpm = XCreatePixmap(gdi_display, root_window, image_w, image_h,
1883                                            physDev->depth);
1884                 GC gc;
1885                 XGCValues gcv;
1886
1887                 gcv.graphics_exposures = False;
1888                 gc = XCreateGC(gdi_display, xpm, GCGraphicsExposures, &gcv);
1889                 XCopyArea(gdi_display, physDev->drawable, xpm, gc, image_x, image_y,
1890                           image_w, image_h, 0, 0);
1891                 XFreeGC(gdi_display, gc);
1892                 X11DRV_expect_error(gdi_display, XRenderErrorHandler, NULL);
1893                 image = XGetImage(gdi_display, xpm, 0, 0, image_w, image_h, AllPlanes,
1894                                   ZPixmap);
1895                 X11DRV_check_error();
1896                 XFreePixmap(gdi_display, xpm);
1897             }
1898             if(!image) goto no_image;
1899
1900             image->red_mask = visual->red_mask;
1901             image->green_mask = visual->green_mask;
1902             image->blue_mask = visual->blue_mask;
1903
1904             offset = xoff = yoff = 0;
1905             for(idx = 0; idx < count; idx++) {
1906                 SmoothGlyphGray(image, xoff + image_off_x - extents.left,
1907                                 yoff + image_off_y - extents.top,
1908                                 formatEntry->bitmaps[wstr[idx]],
1909                                 &formatEntry->gis[wstr[idx]],
1910                                 physDev->textPixel);
1911                 if(lpDx) {
1912                     offset += lpDx[idx];
1913                     xoff = offset * cosEsc;
1914                     yoff = offset * -sinEsc;
1915                 } else {
1916                     xoff += formatEntry->gis[wstr[idx]].xOff;
1917                     yoff += formatEntry->gis[wstr[idx]].yOff;
1918                 }
1919             }
1920             XPutImage(gdi_display, physDev->drawable, physDev->gc, image, 0, 0,
1921                       image_x, image_y, image_w, image_h);
1922             XDestroyImage(image);
1923         }
1924     no_image:
1925         wine_tsx11_unlock();
1926     }
1927     LeaveCriticalSection(&xrender_cs);
1928
1929     if (flags & ETO_CLIPPED)
1930     {
1931         /* restore the device region */
1932         X11DRV_SetDeviceClipping( physDev, saved_region, 0 );
1933         DeleteObject( saved_region );
1934     }
1935
1936     retv = TRUE;
1937
1938 done_unlock:
1939     X11DRV_UnlockDIBSection( physDev, TRUE );
1940     return retv;
1941 }
1942
1943 /* Helper function for (stretched) blitting using xrender */
1944 static void xrender_blit( int op, Picture src_pict, Picture mask_pict, Picture dst_pict,
1945                           int x_src, int y_src, int x_dst, int y_dst,
1946                           double xscale, double yscale, int width, int height )
1947 {
1948     int x_offset, y_offset;
1949
1950     /* When we need to scale we perform scaling and source_x / source_y translation using a transformation matrix.
1951      * This is needed because XRender is inaccurate in combination with scaled source coordinates passed to XRenderComposite.
1952      * In all other cases we do use XRenderComposite for translation as it is faster than using a transformation matrix. */
1953     if(xscale != 1.0 || yscale != 1.0)
1954     {
1955         /* In case of mirroring we need a source x- and y-offset because without the pixels will be
1956          * in the wrong quadrant of the x-y plane.
1957          */
1958         x_offset = (xscale < 0) ? -width : 0;
1959         y_offset = (yscale < 0) ? -height : 0;
1960         set_xrender_transformation(src_pict, xscale, yscale, x_src, y_src);
1961     }
1962     else
1963     {
1964         x_offset = x_src;
1965         y_offset = y_src;
1966         set_xrender_transformation(src_pict, 1, 1, 0, 0);
1967     }
1968     pXRenderComposite( gdi_display, op, src_pict, mask_pict, dst_pict,
1969                        x_offset, y_offset, 0, 0, x_dst, y_dst, width, height );
1970 }
1971
1972 /* Helper function for (stretched) mono->color blitting using xrender */
1973 static void xrender_mono_blit( Picture src_pict, Picture mask_pict, Picture dst_pict,
1974                                int x_src, int y_src, double xscale, double yscale, int width, int height )
1975 {
1976     int x_offset, y_offset;
1977
1978     /* When doing a mono->color blit, 'src_pict' contains a 1x1 picture for tiling, the actual
1979      * source data is in mask_pict.  The 'src_pict' data effectively acts as an alpha channel to the
1980      * tile data. We need PictOpOver for correct rendering.
1981      * Note since the 'source data' is in the mask picture, we have to pass x_src / y_src using
1982      * mask_x / mask_y
1983      */
1984     if (xscale != 1.0 || yscale != 1.0)
1985     {
1986         /* In case of mirroring we need a source x- and y-offset because without the pixels will be
1987          * in the wrong quadrant of the x-y plane.
1988          */
1989         x_offset = (xscale < 0) ? -width : 0;
1990         y_offset = (yscale < 0) ? -height : 0;
1991         set_xrender_transformation(mask_pict, xscale, yscale, x_src, y_src);
1992     }
1993     else
1994     {
1995         x_offset = x_src;
1996         y_offset = y_src;
1997         set_xrender_transformation(mask_pict, 1, 1, 0, 0);
1998     }
1999     pXRenderComposite(gdi_display, PictOpOver, src_pict, mask_pict, dst_pict,
2000                       0, 0, x_offset, y_offset, 0, 0, width, height);
2001 }
2002
2003 /******************************************************************************
2004  * AlphaBlend
2005  */
2006 BOOL XRender_AlphaBlend( X11DRV_PDEVICE *devDst, X11DRV_PDEVICE *devSrc,
2007                          struct bitblt_coords *dst, struct bitblt_coords *src, BLENDFUNCTION blendfn )
2008 {
2009     Picture dst_pict, src_pict = 0, mask_pict = 0, tmp_pict = 0;
2010     struct xrender_info *src_info = get_xrender_info( devSrc );
2011     double xscale, yscale;
2012     BOOL use_repeat;
2013
2014     if(!X11DRV_XRender_Installed) {
2015         FIXME("Unable to AlphaBlend without Xrender\n");
2016         return FALSE;
2017     }
2018
2019     if (devSrc != devDst) X11DRV_LockDIBSection( devSrc, DIB_Status_GdiMod );
2020     X11DRV_LockDIBSection( devDst, DIB_Status_GdiMod );
2021
2022     dst_pict = get_xrender_picture( devDst );
2023
2024     use_repeat = use_source_repeat( devSrc );
2025     if (!use_repeat)
2026     {
2027         xscale = src->width / (double)dst->width;
2028         yscale = src->height / (double)dst->height;
2029     }
2030     else xscale = yscale = 1;  /* no scaling needed with a repeating source */
2031
2032     if (!(blendfn.AlphaFormat & AC_SRC_ALPHA) && src_info->format)
2033     {
2034         /* we need a source picture with no alpha */
2035         WXRFormat format = get_format_without_alpha( src_info->format->format );
2036         if (format != src_info->format->format)
2037         {
2038             XRenderPictureAttributes pa;
2039             const WineXRenderFormat *fmt = get_xrender_format( format );
2040
2041             wine_tsx11_lock();
2042             pa.subwindow_mode = IncludeInferiors;
2043             pa.repeat = use_repeat ? RepeatNormal : RepeatNone;
2044             tmp_pict = pXRenderCreatePicture( gdi_display, devSrc->drawable, fmt->pict_format,
2045                                               CPSubwindowMode|CPRepeat, &pa );
2046             wine_tsx11_unlock();
2047             src_pict = tmp_pict;
2048         }
2049     }
2050
2051     if (!src_pict) src_pict = get_xrender_picture_source( devSrc, use_repeat );
2052
2053     EnterCriticalSection( &xrender_cs );
2054     mask_pict = get_mask_pict( blendfn.SourceConstantAlpha * 257 );
2055
2056     wine_tsx11_lock();
2057     xrender_blit( PictOpOver, src_pict, mask_pict, dst_pict,
2058                   devSrc->dc_rect.left + src->visrect.left, devSrc->dc_rect.top + src->visrect.top,
2059                   devDst->dc_rect.left + dst->visrect.left, devDst->dc_rect.top + dst->visrect.top,
2060                   xscale, yscale,
2061                   dst->visrect.right - dst->visrect.left, dst->visrect.bottom - dst->visrect.top );
2062     if (tmp_pict) pXRenderFreePicture( gdi_display, tmp_pict );
2063     wine_tsx11_unlock();
2064
2065     LeaveCriticalSection( &xrender_cs );
2066     if (devSrc != devDst) X11DRV_UnlockDIBSection( devSrc, FALSE );
2067     X11DRV_UnlockDIBSection( devDst, TRUE );
2068     return TRUE;
2069 }
2070
2071
2072 void X11DRV_XRender_CopyBrush(X11DRV_PDEVICE *physDev, X_PHYSBITMAP *physBitmap, int width, int height)
2073 {
2074     /* 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 */
2075     int depth = physBitmap->pixmap_depth == 1 ? 1 : physDev->depth;
2076     const WineXRenderFormat *src_format = get_xrender_format_from_color_shifts(physBitmap->pixmap_depth, &physBitmap->pixmap_color_shifts);
2077     const WineXRenderFormat *dst_format = get_xrender_format_from_color_shifts(physDev->depth, physDev->color_shifts);
2078
2079     wine_tsx11_lock();
2080     physDev->brush.pixmap = XCreatePixmap(gdi_display, root_window, width, height, depth);
2081
2082     /* Use XCopyArea when the physBitmap and brush.pixmap have the same format. */
2083     if( (physBitmap->pixmap_depth == 1) || (!X11DRV_XRender_Installed && physDev->depth == physBitmap->pixmap_depth) ||
2084         (src_format->format == dst_format->format) )
2085     {
2086         XCopyArea( gdi_display, physBitmap->pixmap, physDev->brush.pixmap,
2087                    get_bitmap_gc(physBitmap->pixmap_depth), 0, 0, width, height, 0, 0 );
2088     }
2089     else /* We need depth conversion */
2090     {
2091         Picture src_pict, dst_pict;
2092         XRenderPictureAttributes pa;
2093         pa.subwindow_mode = IncludeInferiors;
2094         pa.repeat = RepeatNone;
2095
2096         src_pict = pXRenderCreatePicture(gdi_display, physBitmap->pixmap, src_format->pict_format, CPSubwindowMode|CPRepeat, &pa);
2097         dst_pict = pXRenderCreatePicture(gdi_display, physDev->brush.pixmap, dst_format->pict_format, CPSubwindowMode|CPRepeat, &pa);
2098
2099         xrender_blit(PictOpSrc, src_pict, 0, dst_pict, 0, 0, 0, 0, 1.0, 1.0, width, height);
2100         pXRenderFreePicture(gdi_display, src_pict);
2101         pXRenderFreePicture(gdi_display, dst_pict);
2102     }
2103     wine_tsx11_unlock();
2104 }
2105
2106 BOOL X11DRV_XRender_GetSrcAreaStretch(X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
2107                                       Pixmap pixmap, GC gc,
2108                                       const struct bitblt_coords *src, const struct bitblt_coords *dst )
2109 {
2110     BOOL stretch = (src->width != dst->width) || (src->height != dst->height);
2111     int width = dst->visrect.right - dst->visrect.left;
2112     int height = dst->visrect.bottom - dst->visrect.top;
2113     int x_src = physDevSrc->dc_rect.left + src->visrect.left;
2114     int y_src = physDevSrc->dc_rect.top + src->visrect.top;
2115     struct xrender_info *src_info = get_xrender_info(physDevSrc);
2116     const WineXRenderFormat *dst_format = get_xrender_format_from_color_shifts(physDevDst->depth, physDevDst->color_shifts);
2117     Picture src_pict=0, dst_pict=0, mask_pict=0;
2118     BOOL use_repeat;
2119     double xscale, yscale;
2120
2121     XRenderPictureAttributes pa;
2122     pa.subwindow_mode = IncludeInferiors;
2123     pa.repeat = RepeatNone;
2124
2125     TRACE("src depth=%d widthSrc=%d heightSrc=%d xSrc=%d ySrc=%d\n",
2126           physDevSrc->depth, src->width, src->height, x_src, y_src);
2127     TRACE("dst depth=%d widthDst=%d heightDst=%d\n", physDevDst->depth, dst->width, dst->height);
2128
2129     if(!X11DRV_XRender_Installed)
2130     {
2131         TRACE("Not using XRender since it is not available or disabled\n");
2132         return FALSE;
2133     }
2134
2135     /* XRender can't handle palettes, so abort */
2136     if(X11DRV_PALETTE_XPixelToPalette)
2137         return FALSE;
2138
2139     /* XRender is of no use in this case */
2140     if((physDevDst->depth == 1) && (physDevSrc->depth > 1))
2141         return FALSE;
2142
2143     /* Just use traditional X copy when the formats match and we don't need stretching */
2144     if((src_info->format->format == dst_format->format) && !stretch)
2145     {
2146         TRACE("Source and destination depth match and no stretching needed falling back to XCopyArea\n");
2147         wine_tsx11_lock();
2148         XCopyArea( gdi_display, physDevSrc->drawable, pixmap, gc, x_src, y_src, width, height, 0, 0);
2149         wine_tsx11_unlock();
2150         return TRUE;
2151     }
2152
2153     use_repeat = use_source_repeat( physDevSrc );
2154     if (!use_repeat)
2155     {
2156         xscale = src->width / (double)dst->width;
2157         yscale = src->height / (double)dst->height;
2158     }
2159     else xscale = yscale = 1;  /* no scaling needed with a repeating source */
2160
2161     /* mono -> color */
2162     if(physDevSrc->depth == 1 && physDevDst->depth > 1)
2163     {
2164         XRenderColor col;
2165         get_xrender_color(dst_format, physDevDst->textPixel, &col);
2166
2167         /* We use the source drawable as a mask */
2168         mask_pict = get_xrender_picture_source( physDevSrc, use_repeat );
2169
2170         /* Use backgroundPixel as the foreground color */
2171         EnterCriticalSection( &xrender_cs );
2172         src_pict = get_tile_pict(dst_format, physDevDst->backgroundPixel);
2173
2174         /* Create a destination picture and fill it with textPixel color as the background color */
2175         wine_tsx11_lock();
2176         dst_pict = pXRenderCreatePicture(gdi_display, pixmap, dst_format->pict_format, CPSubwindowMode|CPRepeat, &pa);
2177         pXRenderFillRectangle(gdi_display, PictOpSrc, dst_pict, &col, 0, 0, width, height);
2178
2179         xrender_mono_blit(src_pict, mask_pict, dst_pict, x_src, y_src, xscale, yscale, width, height);
2180
2181         if(dst_pict) pXRenderFreePicture(gdi_display, dst_pict);
2182         wine_tsx11_unlock();
2183         LeaveCriticalSection( &xrender_cs );
2184     }
2185     else /* color -> color (can be at different depths) or mono -> mono */
2186     {
2187         src_pict = get_xrender_picture_source( physDevSrc, use_repeat );
2188
2189         wine_tsx11_lock();
2190         dst_pict = pXRenderCreatePicture(gdi_display,
2191                                           pixmap, dst_format->pict_format,
2192                                           CPSubwindowMode|CPRepeat, &pa);
2193
2194         xrender_blit(PictOpSrc, src_pict, 0, dst_pict, x_src, y_src, 0, 0, xscale, yscale, width, height);
2195
2196         if(dst_pict) pXRenderFreePicture(gdi_display, dst_pict);
2197         wine_tsx11_unlock();
2198     }
2199     return TRUE;
2200 }
2201
2202 #else /* SONAME_LIBXRENDER */
2203
2204 void X11DRV_XRender_Init(void)
2205 {
2206     TRACE("XRender support not compiled in.\n");
2207     return;
2208 }
2209
2210 void X11DRV_XRender_Finalize(void)
2211 {
2212 }
2213
2214 BOOL X11DRV_XRender_SelectFont(X11DRV_PDEVICE *physDev, HFONT hfont)
2215 {
2216   assert(0);
2217   return FALSE;
2218 }
2219
2220 void X11DRV_XRender_DeleteDC(X11DRV_PDEVICE *physDev)
2221 {
2222   assert(0);
2223   return;
2224 }
2225
2226 void X11DRV_XRender_SetDeviceClipping(X11DRV_PDEVICE *physDev, const RGNDATA *data)
2227 {
2228     assert(0);
2229     return;
2230 }
2231
2232 BOOL X11DRV_XRender_ExtTextOut( X11DRV_PDEVICE *physDev, INT x, INT y, UINT flags,
2233                                 const RECT *lprect, LPCWSTR wstr, UINT count,
2234                                 const INT *lpDx )
2235 {
2236   assert(0);
2237   return FALSE;
2238 }
2239
2240 void X11DRV_XRender_UpdateDrawable(X11DRV_PDEVICE *physDev)
2241 {
2242   assert(0);
2243   return;
2244 }
2245
2246 BOOL XRender_AlphaBlend( X11DRV_PDEVICE *devDst, X11DRV_PDEVICE *devSrc,
2247                          struct bitblt_coords *dst, struct bitblt_coords *src, BLENDFUNCTION blendfn )
2248 {
2249   FIXME("not supported - XRENDER headers were missing at compile time\n");
2250   return FALSE;
2251 }
2252
2253 void X11DRV_XRender_CopyBrush(X11DRV_PDEVICE *physDev, X_PHYSBITMAP *physBitmap, int width, int height)
2254 {
2255     wine_tsx11_lock();
2256     physDev->brush.pixmap = XCreatePixmap(gdi_display, root_window, width, height, physBitmap->pixmap_depth);
2257
2258     XCopyArea( gdi_display, physBitmap->pixmap, physDev->brush.pixmap,
2259                get_bitmap_gc(physBitmap->pixmap_depth), 0, 0, width, height, 0, 0 );
2260     wine_tsx11_unlock();
2261 }
2262
2263 BOOL X11DRV_XRender_SetPhysBitmapDepth(X_PHYSBITMAP *physBitmap, int bits_pixel, const DIBSECTION *dib)
2264 {
2265     return FALSE;
2266 }
2267
2268 BOOL X11DRV_XRender_GetSrcAreaStretch(X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
2269                                       Pixmap pixmap, GC gc,
2270                                       const struct bitblt_coords *src, const struct bitblt_coords *dst )
2271 {
2272     return FALSE;
2273 }
2274 #endif /* SONAME_LIBXRENDER */