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

   1 /*
   2  * X11DRV device-independent bitmaps
   3  *
   4  * Copyright 1993,1994  Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "config.h"
  22 #include "wine/port.h"
  23
  24 #include <X11/Xlib.h>
  25 #ifdef HAVE_LIBXXSHM
  26 #include <X11/extensions/XShm.h>
  27 # ifdef HAVE_SYS_SHM_H
  28 #  include <sys/shm.h>
  29 # endif
  30 # ifdef HAVE_SYS_IPC_H
  31 #  include <sys/ipc.h>
  32 # endif
  33 #endif /* defined(HAVE_LIBXXSHM) */
  34
  35 #include <stdarg.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include "windef.h"
  39 #include "winbase.h"
  40 #include "wingdi.h"
  41 #include "x11drv.h"
  42 #include "wine/exception.h"
  43 #include "wine/debug.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(bitmap);
  46
  47 static struct list dibs_list = LIST_INIT(dibs_list);
  48
  49 static CRITICAL_SECTION dibs_cs;
  50 static CRITICAL_SECTION_DEBUG dibs_cs_debug =
  51 {
  52     0, 0, &dibs_cs,
  53     { &dibs_cs_debug.ProcessLocksList, &dibs_cs_debug.ProcessLocksList },
  54       0, 0, { (DWORD_PTR)(__FILE__ ": dibs_cs") }
  55 };
  56 static CRITICAL_SECTION dibs_cs = { &dibs_cs_debug, -1, 0, 0, 0, 0 };
  57
  58 static PVOID dibs_handler;
  59
  60 static int ximageDepthTable[32];
  61
  62 /* This structure holds the arguments for DIB_SetImageBits() */
  63 typedef struct
  64 {
  65     X11DRV_PDEVICE         *physDev;
  66     LPCVOID                 bits;
  67     XImage                 *image;
  68     PALETTEENTRY           *palentry;
  69     int                     lines;
  70     DWORD                   infoWidth;
  71     WORD                    depth;
  72     WORD                    infoBpp;
  73     WORD                    compression;
  74     ColorShifts            *shifts;
  75     RGBQUAD                *colorMap;
  76     int                     nColorMap;
  77     Drawable                drawable;
  78     GC                      gc;
  79     int                     xSrc;
  80     int                     ySrc;
  81     int                     xDest;
  82     int                     yDest;
  83     int                     width;
  84     int                     height;
  85     DWORD                   rMask;
  86     DWORD                   gMask;
  87     DWORD                   bMask;
  88     enum x11drv_shm_mode    shm_mode;
  89     int                     dibpitch;
  90     DWORD                   sizeImage;
  91     X_PHYSBITMAP           *physBitmap;
  92 } X11DRV_DIB_IMAGEBITS_DESCR;
  93
  94
  95 enum Rle_EscapeCodes
  96 {
  97   RLE_EOL   = 0, /* End of line */
  98   RLE_END   = 1, /* End of bitmap */
  99   RLE_DELTA = 2  /* Delta */
 100 };
 101
 102
 103 static INT X11DRV_DIB_Coerce(X_PHYSBITMAP *,INT);
 104 static INT X11DRV_DIB_Lock(X_PHYSBITMAP *,INT);
 105 static void X11DRV_DIB_Unlock(X_PHYSBITMAP *,BOOL);
 106
 107 /*
 108   Some of the following helper functions are duplicated in
 109   dlls/gdi/dib.c
 110 */
 111
 112 /***********************************************************************
 113  *           DIB_DoProtectDIBSection
 114  */
 115 static void X11DRV_DIB_DoProtectDIBSection( X_PHYSBITMAP *physBitmap, DWORD new_prot )
 116 {
 117     DWORD old_prot;
 118
 119     VirtualProtect(physBitmap->base, physBitmap->size, new_prot, &old_prot);
 120     TRACE("Changed protection from %d to %d\n", old_prot, new_prot);
 121 }
 122
 123 /***********************************************************************
 124  *           X11DRV_DIB_GetXImageWidthBytes
 125  *
 126  * Return the width of an X image in bytes
 127  */
 128 static inline int X11DRV_DIB_GetXImageWidthBytes( int width, int depth )
 129 {
 130     if (!depth || depth > 32) goto error;
 131
 132     if (!ximageDepthTable[depth-1])
 133     {
 134         XImage *testimage = XCreateImage( gdi_display, visual, depth,
 135                                           ZPixmap, 0, NULL, 1, 1, 32, 20 );
 136         if (testimage)
 137         {
 138             ximageDepthTable[depth-1] = testimage->bits_per_pixel;
 139             XDestroyImage( testimage );
 140         }
 141         else ximageDepthTable[depth-1] = -1;
 142     }
 143     if (ximageDepthTable[depth-1] != -1)
 144         return (4 * ((width * ximageDepthTable[depth-1] + 31) / 32));
 145
 146  error:
 147     WARN( "(%d): Unsupported depth\n", depth );
 148     return 4 * width;
 149 }
 150
 151
 152 /***********************************************************************
 153  *           X11DRV_DIB_GetDIBWidthBytes
 154  *
 155  * Return the width of a DIB bitmap in bytes. DIB bitmap data is 32-bit aligned.
 156  */
 157 static int X11DRV_DIB_GetDIBWidthBytes( int width, int depth )
 158 {
 159     int words;
 160
 161     switch(depth)
 162     {
 163     case 1:  words = (width + 31) / 32; break;
 164     case 4:  words = (width + 7) / 8; break;
 165     case 8:  words = (width + 3) / 4; break;
 166     case 15:
 167     case 16: words = (width + 1) / 2; break;
 168     case 24: words = (width * 3 + 3) / 4; break;
 169     default:
 170         WARN("(%d): Unsupported depth\n", depth );
 171         /* fall through */
 172     case 32:
 173         words = width;
 174     }
 175     return 4 * words;
 176 }
 177
 178
 179 /***********************************************************************
 180  *           X11DRV_DIB_GetDIBImageBytes
 181  *
 182  * Return the number of bytes used to hold the image in a DIB bitmap.
 183  */
 184 static int X11DRV_DIB_GetDIBImageBytes( int width, int height, int depth )
 185 {
 186     return X11DRV_DIB_GetDIBWidthBytes( width, depth ) * abs( height );
 187 }
 188
 189
 190 /***********************************************************************
 191  *           bitmap_info_size
 192  *
 193  * Return the size of the bitmap info structure including color table.
 194  */
 195 int bitmap_info_size( const BITMAPINFO * info, WORD coloruse )
 196 {
 197     unsigned int colors, size, masks = 0;
 198
 199     if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
 200     {
 201         const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)info;
 202         colors = (core->bcBitCount <= 8) ? 1 << core->bcBitCount : 0;
 203         return sizeof(BITMAPCOREHEADER) + colors *
 204              ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
 205     }
 206     else  /* assume BITMAPINFOHEADER */
 207     {
 208         colors = info->bmiHeader.biClrUsed;
 209         if (!colors && (info->bmiHeader.biBitCount <= 8))
 210             colors = 1 << info->bmiHeader.biBitCount;
 211         if (info->bmiHeader.biCompression == BI_BITFIELDS) masks = 3;
 212         size = max( info->bmiHeader.biSize, sizeof(BITMAPINFOHEADER) + masks * sizeof(DWORD) );
 213         return size + colors * ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
 214     }
 215 }
 216
 217
 218 /***********************************************************************
 219  *           X11DRV_DIB_CreateXImage
 220  *
 221  * Create an X image.
 222  */
 223 XImage *X11DRV_DIB_CreateXImage( int width, int height, int depth )
 224 {
 225     int width_bytes;
 226     XImage *image = NULL;
 227     void *data;
 228
 229     wine_tsx11_lock();
 230     width_bytes = X11DRV_DIB_GetXImageWidthBytes( width, depth );
 231     data = HeapAlloc( GetProcessHeap(), 0, height * width_bytes );
 232     if (data) image = XCreateImage( gdi_display, visual, depth, ZPixmap, 0,
 233                                     data, width, height, 32, width_bytes );
 234     if (!image) HeapFree( GetProcessHeap(), 0, data );
 235     wine_tsx11_unlock();
 236     return image;
 237 }
 238
 239
 240 /***********************************************************************
 241  *           X11DRV_DIB_DestroyXImage
 242  *
 243  * Destroy an X image created with X11DRV_DIB_CreateXImage.
 244  */
 245 void X11DRV_DIB_DestroyXImage( XImage *image )
 246 {
 247     HeapFree( GetProcessHeap(), 0, image->data );
 248     image->data = NULL;
 249     wine_tsx11_lock();
 250     XDestroyImage( image );
 251     wine_tsx11_unlock();
 252 }
 253
 254
 255 /***********************************************************************
 256  *           DIB_GetBitmapInfoEx
 257  *
 258  * Get the info from a bitmap header.
 259  * Return 1 for INFOHEADER, 0 for COREHEADER, -1 for error.
 260  */
 261 static int DIB_GetBitmapInfoEx( const BITMAPINFOHEADER *header, LONG *width,
 262                                 LONG *height, WORD *planes, WORD *bpp,
 263                                 WORD *compr, DWORD *size )
 264 {
 265     if (header->biSize == sizeof(BITMAPCOREHEADER))
 266     {
 267         const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)header;
 268         *width  = core->bcWidth;
 269         *height = core->bcHeight;
 270         *planes = core->bcPlanes;
 271         *bpp    = core->bcBitCount;
 272         *compr  = 0;
 273         *size   = 0;
 274         return 0;
 275     }
 276     if (header->biSize >= sizeof(BITMAPINFOHEADER))
 277     {
 278         *width  = header->biWidth;
 279         *height = header->biHeight;
 280         *planes = header->biPlanes;
 281         *bpp    = header->biBitCount;
 282         *compr  = header->biCompression;
 283         *size   = header->biSizeImage;
 284         return 1;
 285     }
 286     ERR("(%d): unknown/wrong size for header\n", header->biSize );
 287     return -1;
 288 }
 289
 290
 291 /***********************************************************************
 292  *           X11DRV_DIB_GetColorCount
 293  *
 294  * Computes the number of colors for the bitmap palette.
 295  * Should not be called for a >8-bit deep bitmap.
 296  */
 297 static unsigned int X11DRV_DIB_GetColorCount(const BITMAPINFO *info)
 298 {
 299     unsigned int colors;
 300     BOOL core_info = info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER);
 301
 302     if (core_info)
 303     {
 304         colors = 1 << ((const BITMAPCOREINFO*)info)->bmciHeader.bcBitCount;
 305     }
 306     else
 307     {
 308         colors = info->bmiHeader.biClrUsed;
 309         if (!colors) colors = 1 << info->bmiHeader.biBitCount;
 310     }
 311     if (colors > 256)
 312     {
 313         ERR("called with >256 colors!\n");
 314         colors = 0;
 315     }
 316     return colors;
 317 }
 318
 319 /***********************************************************************
 320  *           DIB_GetBitmapInfo
 321  *
 322  * Get the info from a bitmap header.
 323  * Return 1 for INFOHEADER, 0 for COREHEADER, -1 for error.
 324  */
 325 static int DIB_GetBitmapInfo( const BITMAPINFOHEADER *header, LONG *width,
 326                               LONG *height, WORD *bpp, WORD *compr )
 327 {
 328     WORD planes;
 329     DWORD size;
 330
 331     return DIB_GetBitmapInfoEx( header, width, height, &planes, bpp, compr, &size);
 332 }
 333
 334
 335 static inline BOOL colour_is_brighter(RGBQUAD c1, RGBQUAD c2)
 336 {
 337     return (c1.rgbRed * c1.rgbRed + c1.rgbGreen * c1.rgbGreen + c1.rgbBlue * c1.rgbBlue) >
 338         (c2.rgbRed * c2.rgbRed + c2.rgbGreen * c2.rgbGreen + c2.rgbBlue * c2.rgbBlue);
 339 }
 340
 341 /***********************************************************************
 342  *           X11DRV_DIB_GenColorMap
 343  *
 344  * Fills the color map of a bitmap palette. Should not be called
 345  * for a >8-bit deep bitmap.
 346  */
 347 static int *X11DRV_DIB_GenColorMap( X11DRV_PDEVICE *physDev, int *colorMapping,
 348                              WORD coloruse, WORD depth, BOOL quads,
 349                              const void *colorPtr, int start, int end )
 350 {
 351     int i;
 352
 353     if (coloruse == DIB_RGB_COLORS)
 354     {
 355         if (quads)
 356         {
 357             const RGBQUAD * rgb = colorPtr;
 358
 359             if (depth == 1)  /* Monochrome */
 360             {
 361                 BOOL invert = FALSE;
 362                 RGBQUAD table[2];
 363
 364                 if (GetDIBColorTable( physDev->hdc, 0, 2, table ) == 2)
 365                     invert = !colour_is_brighter(table[1], table[0]);
 366
 367                 for (i = start; i < end; i++, rgb++)
 368                     colorMapping[i] = ((rgb->rgbRed + rgb->rgbGreen +
 369                                         rgb->rgbBlue > 255*3/2 && !invert) ||
 370                                        (rgb->rgbRed + rgb->rgbGreen +
 371                                         rgb->rgbBlue <= 255*3/2 && invert));
 372             }
 373             else
 374                 for (i = start; i < end; i++, rgb++)
 375                     colorMapping[i] = X11DRV_PALETTE_LookupPixel(physDev->color_shifts, RGB(rgb->rgbRed,
 376                                                                 rgb->rgbGreen,
 377                                                                 rgb->rgbBlue));
 378         }
 379         else
 380         {
 381             const RGBTRIPLE * rgb = colorPtr;
 382
 383             if (depth == 1)  /* Monochrome */
 384             {
 385                 BOOL invert = FALSE;
 386                 RGBQUAD table[2];
 387
 388                 if (GetDIBColorTable( physDev->hdc, 0, 2, table ) == 2)
 389                     invert = !colour_is_brighter(table[1], table[0]);
 390
 391                 for (i = start; i < end; i++, rgb++)
 392                     colorMapping[i] = ((rgb->rgbtRed + rgb->rgbtGreen +
 393                                         rgb->rgbtBlue > 255*3/2 && !invert) ||
 394                                        (rgb->rgbtRed + rgb->rgbtGreen +
 395                                         rgb->rgbtBlue <= 255*3/2 && invert));
 396             }
 397             else
 398                 for (i = start; i < end; i++, rgb++)
 399                     colorMapping[i] = X11DRV_PALETTE_LookupPixel(physDev->color_shifts, RGB(rgb->rgbtRed,
 400                                                                rgb->rgbtGreen,
 401                                                                rgb->rgbtBlue));
 402         }
 403     }
 404     else  /* DIB_PAL_COLORS */
 405     {
 406         const WORD * index = colorPtr;
 407
 408         for (i = start; i < end; i++, index++)
 409             colorMapping[i] = X11DRV_PALETTE_ToPhysical( physDev, PALETTEINDEX(*index) );
 410     }
 411
 412     return colorMapping;
 413 }
 414
 415 /***********************************************************************
 416  *           X11DRV_DIB_BuildColorMap
 417  *
 418  * Build the color map from the bitmap palette. Should not be called
 419  * for a >8-bit deep bitmap.
 420  */
 421 static int *X11DRV_DIB_BuildColorMap( X11DRV_PDEVICE *physDev, WORD coloruse, WORD depth,
 422                                       const BITMAPINFO *info, int *nColors )
 423 {
 424     BOOL isInfo;
 425     const void *colorPtr;
 426     int *colorMapping;
 427
 428
 429     *nColors = X11DRV_DIB_GetColorCount(info);
 430     if (!*nColors) return NULL;
 431
 432     isInfo = info->bmiHeader.biSize != sizeof(BITMAPCOREHEADER);
 433     colorPtr = (const BYTE*)info + (WORD)info->bmiHeader.biSize;
 434     if (!(colorMapping = HeapAlloc(GetProcessHeap(), 0, *nColors * sizeof(int) )))
 435         return NULL;
 436
 437     return X11DRV_DIB_GenColorMap( physDev, colorMapping, coloruse, depth,
 438                                    isInfo, colorPtr, 0, *nColors);
 439 }
 440
 441 /***********************************************************************
 442  *           X11DRV_DIB_MapColor
 443  */
 444 static int X11DRV_DIB_MapColor( int *physMap, int nPhysMap, int phys, int oldcol )
 445 {
 446     int color;
 447
 448     if ((oldcol < nPhysMap) && (physMap[oldcol] == phys))
 449         return oldcol;
 450
 451     for (color = 0; color < nPhysMap; color++)
 452         if (physMap[color] == phys)
 453             return color;
 454
 455     WARN("Strange color %08x\n", phys);
 456     return 0;
 457 }
 458
 459
 460 /*********************************************************************
 461  *         X11DRV_DIB_GetNearestIndex
 462  *
 463  * Helper for X11DRV_DIB_GetDIBits.
 464  * Returns the nearest colour table index for a given RGB.
 465  * Nearest is defined by minimizing the sum of the squares.
 466  */
 467 static INT X11DRV_DIB_GetNearestIndex(RGBQUAD *colormap, int numColors, BYTE r, BYTE g, BYTE b)
 468 {
 469     INT i, best = -1, diff, bestdiff = -1;
 470     RGBQUAD *color;
 471
 472     for(color = colormap, i = 0; i < numColors; color++, i++) {
 473         diff = (r - color->rgbRed) * (r - color->rgbRed) +
 474                (g - color->rgbGreen) * (g - color->rgbGreen) +
 475                (b - color->rgbBlue) * (b - color->rgbBlue);
 476         if(diff == 0)
 477             return i;
 478         if(best == -1 || diff < bestdiff) {
 479             best = i;
 480             bestdiff = diff;
 481         }
 482     }
 483     return best;
 484 }
 485 /*********************************************************************
 486  *         X11DRV_DIB_MaskToShift
 487  *
 488  * Helper for X11DRV_DIB_GetDIBits.
 489  * Returns the by how many bits to shift a given color so that it is
 490  * in the proper position.
 491  */
 492 INT X11DRV_DIB_MaskToShift(DWORD mask)
 493 {
 494     int shift;
 495
 496     if (mask==0)
 497         return 0;
 498
 499     shift=0;
 500     while ((mask&1)==0) {
 501         mask>>=1;
 502         shift++;
 503     }
 504     return shift;
 505 }
 506
 507 /***********************************************************************
 508  *           X11DRV_DIB_CheckMask
 509  *
 510  * Check RGB mask if it is either 0 or matches visual's mask.
 511  */
 512 static inline int X11DRV_DIB_CheckMask(int red_mask, int green_mask, int blue_mask)
 513 {
 514     return ( red_mask == 0 && green_mask == 0 && blue_mask == 0 ) ||
 515            ( red_mask == visual->red_mask && green_mask == visual->green_mask &&
 516              blue_mask == visual->blue_mask );
 517 }
 518
 519 /***********************************************************************
 520  *           X11DRV_DIB_SetImageBits_1
 521  *
 522  * SetDIBits for a 1-bit deep DIB.
 523  */
 524 static void X11DRV_DIB_SetImageBits_1( int lines, const BYTE *srcbits,
 525                                 DWORD srcwidth, DWORD dstwidth, int left,
 526                                 int *colors, XImage *bmpImage, int linebytes)
 527 {
 528     int h, width;
 529     const BYTE* srcbyte;
 530     BYTE srcval, extra;
 531     DWORD i, x;
 532
 533     if (lines < 0 ) {
 534         lines = -lines;
 535         srcbits = srcbits + linebytes * (lines - 1);
 536         linebytes = -linebytes;
 537     }
 538
 539     if ((extra = (left & 7)) != 0) {
 540         left &= ~7;
 541         dstwidth += extra;
 542     }
 543     srcbits += left >> 3;
 544     width = min(srcwidth, dstwidth);
 545
 546     /* ==== pal 1 dib -> any bmp format ==== */
 547     for (h = lines-1; h >=0; h--) {
 548         srcbyte=srcbits;
 549         for (i = width/8, x = left; i > 0; i--) {
 550             srcval=*srcbyte++;
 551             XPutPixel( bmpImage, x++, h, colors[ srcval >> 7] );
 552             XPutPixel( bmpImage, x++, h, colors[(srcval >> 6) & 1] );
 553             XPutPixel( bmpImage, x++, h, colors[(srcval >> 5) & 1] );
 554             XPutPixel( bmpImage, x++, h, colors[(srcval >> 4) & 1] );
 555             XPutPixel( bmpImage, x++, h, colors[(srcval >> 3) & 1] );
 556             XPutPixel( bmpImage, x++, h, colors[(srcval >> 2) & 1] );
 557             XPutPixel( bmpImage, x++, h, colors[(srcval >> 1) & 1] );
 558             XPutPixel( bmpImage, x++, h, colors[ srcval       & 1] );
 559         }
 560         if (width % 8){
 561             srcval=*srcbyte;
 562             switch (width & 7)
 563             {
 564             case 7: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
 565             case 6: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
 566             case 5: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
 567             case 4: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
 568             case 3: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
 569             case 2: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
 570             case 1: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]);
 571             }
 572         }
 573         srcbits += linebytes;
 574     }
 575 }
 576
 577 /***********************************************************************
 578  *           X11DRV_DIB_GetImageBits_1
 579  *
 580  * GetDIBits for a 1-bit deep DIB.
 581  */
 582 static void X11DRV_DIB_GetImageBits_1( int lines, BYTE *dstbits,
 583                                        DWORD dstwidth, DWORD srcwidth,
 584                                        RGBQUAD *colors, PALETTEENTRY *srccolors,
 585                                        XImage *bmpImage, int linebytes )
 586 {
 587     DWORD x;
 588     int h, width = min(dstwidth, srcwidth);
 589
 590     if (lines < 0 ) {
 591         lines = -lines;
 592         dstbits = dstbits + linebytes * (lines - 1);
 593         linebytes = -linebytes;
 594     }
 595
 596     switch (bmpImage->depth)
 597     {
 598     case 1:
 599     case 4:
 600         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
 601             && srccolors) {
 602             /* ==== pal 1 or 4 bmp -> pal 1 dib ==== */
 603             BYTE* dstbyte;
 604
 605             for (h=lines-1; h>=0; h--) {
 606                 BYTE dstval;
 607                 dstbyte=dstbits;
 608                 dstval=0;
 609                 for (x=0; x<width; x++) {
 610                     PALETTEENTRY srcval;
 611                     srcval=srccolors[XGetPixel(bmpImage, x, h)];
 612                     dstval|=(X11DRV_DIB_GetNearestIndex
 613                              (colors, 2,
 614                               srcval.peRed,
 615                               srcval.peGreen,
 616                               srcval.peBlue) << (7 - (x & 7)));
 617                     if ((x&7)==7) {
 618                         *dstbyte++=dstval;
 619                         dstval=0;
 620                     }
 621                 }
 622                 if ((width&7)!=0) {
 623                     *dstbyte++=dstval;
 624                 }
 625                 /* pad with 0 to DWORD alignment */
 626                 for (x = (x+7)&~7; x < ((width + 31) & ~31); x+=8)
 627                     *dstbyte++ = 0;
 628                 dstbits += linebytes;
 629             }
 630         } else {
 631             goto notsupported;
 632         }
 633         break;
 634
 635     case 8:
 636         if (X11DRV_DIB_CheckMask(bmpImage->red_mask, bmpImage->green_mask, bmpImage->blue_mask)
 637             && srccolors) {
 638             /* ==== pal 8 bmp -> pal 1 dib ==== */
 639             const void* srcbits;
 640             const BYTE* srcpixel;
 641             BYTE* dstbyte;
 642
 643             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
 644
 645             for (h=0; h<lines; h++) {
 646                 BYTE dstval;
 647                 srcpixel=srcbits;
 648                 dstbyte=dstbits;
 649                 dstval=0;
 650                 for (x=0; x<width; x++) {
 651                     PALETTEENTRY srcval;
 652                     srcval=srccolors[*srcpixel++];
 653                     dstval|=(X11DRV_DIB_GetNearestIndex
 654                              (colors, 2,
 655                               srcval.peRed,
 656                               srcval.peGreen,
 657                               srcval.peBlue) << (7-(x&7)) );
 658                     if ((x&7)==7) {
 659                         *dstbyte++=dstval;
 660                         dstval=0;
 661                     }
 662                 }
 663                 if ((width&7)!=0) {
 664                     *dstbyte=dstval;
 665                 }
 666                 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
 667                 dstbits += linebytes;
 668             }
 669         } else {
 670             goto notsupported;
 671         }
 672         break;
 673
 674     case 15:
 675     case 16:
 676         {
 677             const void* srcbits;
 678             const WORD* srcpixel;
 679             BYTE* dstbyte;
 680
 681             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
 682
 683             if (bmpImage->green_mask==0x03e0) {
 684                 if (bmpImage->red_mask==0x7c00) {
 685                     /* ==== rgb 555 bmp -> pal 1 dib ==== */
 686                     for (h=0; h<lines; h++) {
 687                         BYTE dstval;
 688                         srcpixel=srcbits;
 689                         dstbyte=dstbits;
 690                         dstval=0;
 691                         for (x=0; x<width; x++) {
 692                             WORD srcval;
 693                             srcval=*srcpixel++;
 694                             dstval|=(X11DRV_DIB_GetNearestIndex
 695                                      (colors, 2,
 696                                       ((srcval >>  7) & 0xf8) | /* r */
 697                                       ((srcval >> 12) & 0x07),
 698                                       ((srcval >>  2) & 0xf8) | /* g */
 699                                       ((srcval >>  7) & 0x07),
 700                                       ((srcval <<  3) & 0xf8) | /* b */
 701                                       ((srcval >>  2) & 0x07) ) << (7-(x&7)) );
 702                             if ((x&7)==7) {
 703                                 *dstbyte++=dstval;
 704                                 dstval=0;
 705                             }
 706                         }
 707                         if ((width&7)!=0) {
 708                             *dstbyte=dstval;
 709                         }
 710                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
 711                         dstbits += linebytes;
 712                     }
 713                 } else if (bmpImage->blue_mask==0x7c00) {
 714                     /* ==== bgr 555 bmp -> pal 1 dib ==== */
 715                     for (h=0; h<lines; h++) {
 716                         WORD dstval;
 717                         srcpixel=srcbits;
 718                         dstbyte=dstbits;
 719                         dstval=0;
 720                         for (x=0; x<width; x++) {
 721                             BYTE srcval;
 722                             srcval=*srcpixel++;
 723                             dstval|=(X11DRV_DIB_GetNearestIndex
 724                                      (colors, 2,
 725                                       ((srcval <<  3) & 0xf8) | /* r */
 726                                       ((srcval >>  2) & 0x07),
 727                                       ((srcval >>  2) & 0xf8) | /* g */
 728                                       ((srcval >>  7) & 0x07),
 729                                       ((srcval >>  7) & 0xf8) | /* b */
 730                                       ((srcval >> 12) & 0x07) ) << (7-(x&7)) );
 731                             if ((x&7)==7) {
 732                                 *dstbyte++=dstval;
 733                                 dstval=0;
 734                             }
 735                         }
 736                         if ((width&7)!=0) {
 737                             *dstbyte=dstval;
 738                         }
 739                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
 740                         dstbits += linebytes;
 741                     }
 742                 } else {
 743                     goto notsupported;
 744                 }
 745             } else if (bmpImage->green_mask==0x07e0) {
 746                 if (bmpImage->red_mask==0xf800) {
 747                     /* ==== rgb 565 bmp -> pal 1 dib ==== */
 748                     for (h=0; h<lines; h++) {
 749                         BYTE dstval;
 750                         srcpixel=srcbits;
 751                         dstbyte=dstbits;
 752                         dstval=0;
 753                         for (x=0; x<width; x++) {
 754                             WORD srcval;
 755                             srcval=*srcpixel++;
 756                             dstval|=(X11DRV_DIB_GetNearestIndex
 757                                      (colors, 2,
 758                                       ((srcval >>  8) & 0xf8) | /* r */
 759                                       ((srcval >> 13) & 0x07),
 760                                       ((srcval >>  3) & 0xfc) | /* g */
 761                                       ((srcval >>  9) & 0x03),
 762                                       ((srcval <<  3) & 0xf8) | /* b */
 763                                       ((srcval >>  2) & 0x07) ) << (7-(x&7)) );
 764                             if ((x&7)==7) {
 765                                 *dstbyte++=dstval;
 766                                 dstval=0;
 767                             }
 768                         }
 769                         if ((width&7)!=0) {
 770                             *dstbyte=dstval;
 771                         }
 772                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
 773                         dstbits += linebytes;
 774                     }
 775                 } else if (bmpImage->blue_mask==0xf800) {
 776                     /* ==== bgr 565 bmp -> pal 1 dib ==== */
 777                     for (h=0; h<lines; h++) {
 778                         BYTE dstval;
 779                         srcpixel=srcbits;
 780                         dstbyte=dstbits;
 781                         dstval=0;
 782                         for (x=0; x<width; x++) {
 783                             WORD srcval;
 784                             srcval=*srcpixel++;
 785                             dstval|=(X11DRV_DIB_GetNearestIndex
 786                                      (colors, 2,
 787                                       ((srcval <<  3) & 0xf8) | /* r */
 788                                       ((srcval >>  2) & 0x07),
 789                                       ((srcval >>  3) & 0xfc) | /* g */
 790                                       ((srcval >>  9) & 0x03),
 791                                       ((srcval >>  8) & 0xf8) | /* b */
 792                                       ((srcval >> 13) & 0x07) ) << (7-(x&7)) );
 793                             if ((x&7)==7) {
 794                                 *dstbyte++=dstval;
 795                                 dstval=0;
 796                             }
 797                         }
 798                         if ((width&7)!=0) {
 799                             *dstbyte=dstval;
 800                         }
 801                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
 802                         dstbits += linebytes;
 803                     }
 804                 } else {
 805                     goto notsupported;
 806                 }
 807             } else {
 808                 goto notsupported;
 809             }
 810         }
 811         break;
 812
 813     case 24:
 814     case 32:
 815         {
 816             const void* srcbits;
 817             const BYTE *srcbyte;
 818             BYTE* dstbyte;
 819             int bytes_per_pixel;
 820
 821             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
 822             bytes_per_pixel=(bmpImage->bits_per_pixel==24?3:4);
 823
 824             if (bmpImage->green_mask!=0x00ff00 ||
 825                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
 826                 goto notsupported;
 827             } else if (bmpImage->blue_mask==0xff) {
 828                 /* ==== rgb 888 or 0888 bmp -> pal 1 dib ==== */
 829                 for (h=0; h<lines; h++) {
 830                     BYTE dstval;
 831                     srcbyte=srcbits;
 832                     dstbyte=dstbits;
 833                     dstval=0;
 834                     for (x=0; x<width; x++) {
 835                         dstval|=(X11DRV_DIB_GetNearestIndex
 836                                  (colors, 2,
 837                                   srcbyte[2],
 838                                   srcbyte[1],
 839                                   srcbyte[0]) << (7-(x&7)) );
 840                         srcbyte+=bytes_per_pixel;
 841                         if ((x&7)==7) {
 842                             *dstbyte++=dstval;
 843                             dstval=0;
 844                         }
 845                     }
 846                     if ((width&7)!=0) {
 847                         *dstbyte=dstval;
 848                     }
 849                     srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
 850                     dstbits += linebytes;
 851                 }
 852             } else {
 853                 /* ==== bgr 888 or 0888 bmp -> pal 1 dib ==== */
 854                 for (h=0; h<lines; h++) {
 855                     BYTE dstval;
 856                     srcbyte=srcbits;
 857                     dstbyte=dstbits;
 858                     dstval=0;
 859                     for (x=0; x<width; x++) {
 860                         dstval|=(X11DRV_DIB_GetNearestIndex
 861                                  (colors, 2,
 862                                   srcbyte[0],
 863                                   srcbyte[1],
 864                                   srcbyte[2]) << (7-(x&7)) );
 865                         srcbyte+=bytes_per_pixel;
 866                         if ((x&7)==7) {
 867                             *dstbyte++=dstval;
 868                             dstval=0;
 869                         }
 870                     }
 871                     if ((width&7)!=0) {
 872                         *dstbyte=dstval;
 873                     }
 874                     srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
 875                     dstbits += linebytes;
 876                 }
 877             }
 878         }
 879         break;
 880
 881     default:
 882     notsupported:
 883         {
 884             BYTE* dstbyte;
 885             BYTE neg = 0;
 886             unsigned long white = (1 << bmpImage->bits_per_pixel) - 1;
 887
 888             /* ==== any bmp format -> pal 1 dib ==== */
 889             if ((unsigned)colors[0].rgbRed+colors[0].rgbGreen+colors[0].rgbBlue >=
 890                 (unsigned)colors[1].rgbRed+colors[1].rgbGreen+colors[1].rgbBlue )
 891                 neg = 1;
 892
 893             WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 1 bit DIB, "
 894                  "%s color mapping\n",
 895                   bmpImage->bits_per_pixel, bmpImage->red_mask,
 896                   bmpImage->green_mask, bmpImage->blue_mask,
 897                   neg?"negative":"direct" );
 898
 899             for (h=lines-1; h>=0; h--) {
 900                 BYTE dstval;
 901                 dstbyte=dstbits;
 902                 dstval=0;
 903                 for (x=0; x<width; x++) {
 904                     dstval|=((XGetPixel( bmpImage, x, h) >= white) ^ neg) << (7 - (x&7));
 905                     if ((x&7)==7) {
 906                         *dstbyte++=dstval;
 907                         dstval=0;
 908                     }
 909                 }
 910                 if ((width&7)!=0) {
 911                     *dstbyte=dstval;
 912                 }
 913                 dstbits += linebytes;
 914             }
 915         }
 916         break;
 917     }
 918 }
 919
 920 /***********************************************************************
 921  *           X11DRV_DIB_SetImageBits_4
 922  *
 923  * SetDIBits for a 4-bit deep DIB.
 924  */
 925 static void X11DRV_DIB_SetImageBits_4( int lines, const BYTE *srcbits,
 926                                 DWORD srcwidth, DWORD dstwidth, int left,
 927                                 int *colors, XImage *bmpImage, int linebytes)
 928 {
 929     int h, width;
 930     const BYTE* srcbyte;
 931     DWORD i, x;
 932
 933     if (lines < 0 ) {
 934         lines = -lines;
 935         srcbits = srcbits + linebytes * (lines - 1);
 936         linebytes = -linebytes;
 937     }
 938
 939     if (left & 1) {
 940         left--;
 941         dstwidth++;
 942     }
 943     srcbits += left >> 1;
 944     width = min(srcwidth, dstwidth);
 945
 946     /* ==== pal 4 dib -> any bmp format ==== */
 947     for (h = lines-1; h >= 0; h--) {
 948         srcbyte=srcbits;
 949         for (i = width/2, x = left; i > 0; i--) {
 950             BYTE srcval=*srcbyte++;
 951             XPutPixel( bmpImage, x++, h, colors[srcval >> 4] );
 952             XPutPixel( bmpImage, x++, h, colors[srcval & 0x0f] );
 953         }
 954         if (width & 1)
 955             XPutPixel( bmpImage, x, h, colors[*srcbyte >> 4] );
 956         srcbits += linebytes;
 957     }
 958 }
 959
 960
 961
 962 /***********************************************************************
 963  *           X11DRV_DIB_GetImageBits_4
 964  *
 965  * GetDIBits for a 4-bit deep DIB.
 966  */
 967 static void X11DRV_DIB_GetImageBits_4( int lines, BYTE *dstbits,
 968                                        DWORD srcwidth, DWORD dstwidth,
 969                                        RGBQUAD *colors, PALETTEENTRY *srccolors,
 970                                        XImage *bmpImage, int linebytes )
 971 {
 972     DWORD x;
 973     int h, width = min(srcwidth, dstwidth);
 974
 975     if (lines < 0 )
 976     {
 977        lines = -lines;
 978        dstbits = dstbits + ( linebytes * (lines-1) );
 979        linebytes = -linebytes;
 980     }
 981
 982     switch (bmpImage->depth) {
 983     case 1:
 984     case 4:
 985         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
 986             && srccolors) {
 987             /* ==== pal 1 or 4 bmp -> pal 4 dib ==== */
 988             BYTE* dstbyte;
 989
 990             for (h = lines-1; h >= 0; h--) {
 991                 BYTE dstval;
 992                 dstbyte=dstbits;
 993                 dstval=0;
 994                 for (x = 0; x < width; x++) {
 995                     PALETTEENTRY srcval;
 996                     srcval=srccolors[XGetPixel(bmpImage, x, h)];
 997                     dstval|=(X11DRV_DIB_GetNearestIndex
 998                              (colors, 16,
 999                               srcval.peRed,
1000                               srcval.peGreen,
1001                               srcval.peBlue) << (4-((x&1)<<2)));
1002                     if ((x&1)==1) {
1003                         *dstbyte++=dstval;
1004                         dstval=0;
1005                     }
1006                 }
1007                 if ((width&1)!=0) {
1008                     *dstbyte=dstval;
1009                 }
1010                 dstbits += linebytes;
1011             }
1012         } else {
1013             goto notsupported;
1014         }
1015         break;
1016
1017     case 8:
1018         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
1019             && srccolors) {
1020             /* ==== pal 8 bmp -> pal 4 dib ==== */
1021             const void* srcbits;
1022             const BYTE *srcpixel;
1023             BYTE* dstbyte;
1024
1025             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1026             for (h=0; h<lines; h++) {
1027                 BYTE dstval;
1028                 srcpixel=srcbits;
1029                 dstbyte=dstbits;
1030                 dstval=0;
1031                 for (x=0; x<width; x++) {
1032                     PALETTEENTRY srcval;
1033                     srcval = srccolors[*srcpixel++];
1034                     dstval|=(X11DRV_DIB_GetNearestIndex
1035                              (colors, 16,
1036                               srcval.peRed,
1037                               srcval.peGreen,
1038                               srcval.peBlue) << (4*(1-(x&1))) );
1039                     if ((x&1)==1) {
1040                         *dstbyte++=dstval;
1041                         dstval=0;
1042                     }
1043                 }
1044                 if ((width&1)!=0) {
1045                     *dstbyte=dstval;
1046                 }
1047                 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1048                 dstbits += linebytes;
1049             }
1050         } else {
1051             goto notsupported;
1052         }
1053         break;
1054
1055     case 15:
1056     case 16:
1057         {
1058             const void* srcbits;
1059             const WORD* srcpixel;
1060             BYTE* dstbyte;
1061
1062             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1063
1064             if (bmpImage->green_mask==0x03e0) {
1065                 if (bmpImage->red_mask==0x7c00) {
1066                     /* ==== rgb 555 bmp -> pal 4 dib ==== */
1067                     for (h=0; h<lines; h++) {
1068                         BYTE dstval;
1069                         srcpixel=srcbits;
1070                         dstbyte=dstbits;
1071                         dstval=0;
1072                         for (x=0; x<width; x++) {
1073                             WORD srcval;
1074                             srcval=*srcpixel++;
1075                             dstval|=(X11DRV_DIB_GetNearestIndex
1076                                      (colors, 16,
1077                                       ((srcval >>  7) & 0xf8) | /* r */
1078                                       ((srcval >> 12) & 0x07),
1079                                       ((srcval >>  2) & 0xf8) | /* g */
1080                                       ((srcval >>  7) & 0x07),
1081                                       ((srcval <<  3) & 0xf8) | /* b */
1082                                       ((srcval >>  2) & 0x07) ) << ((1-(x&1))<<2) );
1083                             if ((x&1)==1) {
1084                                 *dstbyte++=dstval;
1085                                 dstval=0;
1086                             }
1087                         }
1088                         if ((width&1)!=0) {
1089                             *dstbyte=dstval;
1090                         }
1091                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1092                         dstbits += linebytes;
1093                     }
1094                 } else if (bmpImage->blue_mask==0x7c00) {
1095                     /* ==== bgr 555 bmp -> pal 4 dib ==== */
1096                     for (h=0; h<lines; h++) {
1097                         WORD dstval;
1098                         srcpixel=srcbits;
1099                         dstbyte=dstbits;
1100                         dstval=0;
1101                         for (x=0; x<width; x++) {
1102                             WORD srcval;
1103                             srcval=*srcpixel++;
1104                             dstval|=(X11DRV_DIB_GetNearestIndex
1105                                      (colors, 16,
1106                                       ((srcval <<  3) & 0xf8) | /* r */
1107                                       ((srcval >>  2) & 0x07),
1108                                       ((srcval >>  2) & 0xf8) | /* g */
1109                                       ((srcval >>  7) & 0x07),
1110                                       ((srcval >>  7) & 0xf8) | /* b */
1111                                       ((srcval >> 12) & 0x07) ) << ((1-(x&1))<<2) );
1112                             if ((x&1)==1) {
1113                                 *dstbyte++=dstval;
1114                                 dstval=0;
1115                             }
1116                         }
1117                         if ((width&1)!=0) {
1118                             *dstbyte=dstval;
1119                         }
1120                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1121                         dstbits += linebytes;
1122                     }
1123                 } else {
1124                     goto notsupported;
1125                 }
1126             } else if (bmpImage->green_mask==0x07e0) {
1127                 if (bmpImage->red_mask==0xf800) {
1128                     /* ==== rgb 565 bmp -> pal 4 dib ==== */
1129                     for (h=0; h<lines; h++) {
1130                         BYTE dstval;
1131                         srcpixel=srcbits;
1132                         dstbyte=dstbits;
1133                         dstval=0;
1134                         for (x=0; x<width; x++) {
1135                             WORD srcval;
1136                             srcval=*srcpixel++;
1137                             dstval|=(X11DRV_DIB_GetNearestIndex
1138                                      (colors, 16,
1139                                       ((srcval >>  8) & 0xf8) | /* r */
1140                                       ((srcval >> 13) & 0x07),
1141                                       ((srcval >>  3) & 0xfc) | /* g */
1142                                       ((srcval >>  9) & 0x03),
1143                                       ((srcval <<  3) & 0xf8) | /* b */
1144                                       ((srcval >>  2) & 0x07) ) << ((1-(x&1))<<2) );
1145                             if ((x&1)==1) {
1146                                 *dstbyte++=dstval;
1147                                 dstval=0;
1148                             }
1149                         }
1150                         if ((width&1)!=0) {
1151                             *dstbyte=dstval;
1152                         }
1153                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1154                         dstbits += linebytes;
1155                     }
1156                 } else if (bmpImage->blue_mask==0xf800) {
1157                     /* ==== bgr 565 bmp -> pal 4 dib ==== */
1158                     for (h=0; h<lines; h++) {
1159                         WORD dstval;
1160                         srcpixel=srcbits;
1161                         dstbyte=dstbits;
1162                         dstval=0;
1163                         for (x=0; x<width; x++) {
1164                             WORD srcval;
1165                             srcval=*srcpixel++;
1166                             dstval|=(X11DRV_DIB_GetNearestIndex
1167                                      (colors, 16,
1168                                       ((srcval <<  3) & 0xf8) | /* r */
1169                                       ((srcval >>  2) & 0x07),
1170                                       ((srcval >>  3) & 0xfc) | /* g */
1171                                       ((srcval >>  9) & 0x03),
1172                                       ((srcval >>  8) & 0xf8) | /* b */
1173                                       ((srcval >> 13) & 0x07) ) << ((1-(x&1))<<2) );
1174                             if ((x&1)==1) {
1175                                 *dstbyte++=dstval;
1176                                 dstval=0;
1177                             }
1178                         }
1179                         if ((width&1)!=0) {
1180                             *dstbyte=dstval;
1181                         }
1182                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1183                         dstbits += linebytes;
1184                     }
1185                 } else {
1186                     goto notsupported;
1187                 }
1188             } else {
1189                 goto notsupported;
1190             }
1191         }
1192         break;
1193
1194     case 24:
1195         if (bmpImage->bits_per_pixel==24) {
1196             const void* srcbits;
1197             const BYTE *srcbyte;
1198             BYTE* dstbyte;
1199
1200             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1201
1202             if (bmpImage->green_mask!=0x00ff00 ||
1203                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
1204                 goto notsupported;
1205             } else if (bmpImage->blue_mask==0xff) {
1206                 /* ==== rgb 888 bmp -> pal 4 dib ==== */
1207                 for (h=0; h<lines; h++) {
1208                     srcbyte=srcbits;
1209                     dstbyte=dstbits;
1210                     for (x=0; x<width/2; x++) {
1211                         /* Do 2 pixels at a time */
1212                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
1213                                     (colors, 16,
1214                                      srcbyte[2],
1215                                      srcbyte[1],
1216                                      srcbyte[0]) << 4) |
1217                                     X11DRV_DIB_GetNearestIndex
1218                                     (colors, 16,
1219                                      srcbyte[5],
1220                                      srcbyte[4],
1221                                      srcbyte[3]);
1222                         srcbyte+=6;
1223                     }
1224                     if (width&1) {
1225                         /* And then the odd pixel */
1226                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
1227                                     (colors, 16,
1228                                      srcbyte[2],
1229                                      srcbyte[1],
1230                                      srcbyte[0]) << 4);
1231                     }
1232                     srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1233                     dstbits += linebytes;
1234                 }
1235             } else {
1236                 /* ==== bgr 888 bmp -> pal 4 dib ==== */
1237                 for (h=0; h<lines; h++) {
1238                     srcbyte=srcbits;
1239                     dstbyte=dstbits;
1240                     for (x=0; x<width/2; x++) {
1241                         /* Do 2 pixels at a time */
1242                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
1243                                     (colors, 16,
1244                                      srcbyte[0],
1245                                      srcbyte[1],
1246                                      srcbyte[2]) << 4) |
1247                                     X11DRV_DIB_GetNearestIndex
1248                                     (colors, 16,
1249                                      srcbyte[3],
1250                                      srcbyte[4],
1251                                      srcbyte[5]);
1252                         srcbyte+=6;
1253                     }
1254                     if (width&1) {
1255                         /* And then the odd pixel */
1256                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
1257                                     (colors, 16,
1258                                      srcbyte[0],
1259                                      srcbyte[1],
1260                                      srcbyte[2]) << 4);
1261                     }
1262                     srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1263                     dstbits += linebytes;
1264                 }
1265             }
1266             break;
1267         }
1268         /* Fall through */
1269
1270     case 32:
1271         {
1272             const void* srcbits;
1273             const BYTE *srcbyte;
1274             BYTE* dstbyte;
1275
1276             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1277
1278             if (bmpImage->green_mask!=0x00ff00 ||
1279                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
1280                 goto notsupported;
1281             } else if (bmpImage->blue_mask==0xff) {
1282                 /* ==== rgb 0888 bmp -> pal 4 dib ==== */
1283                 for (h=0; h<lines; h++) {
1284                     srcbyte=srcbits;
1285                     dstbyte=dstbits;
1286                     for (x=0; x<width/2; x++) {
1287                         /* Do 2 pixels at a time */
1288                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
1289                                     (colors, 16,
1290                                      srcbyte[2],
1291                                      srcbyte[1],
1292                                      srcbyte[0]) << 4) |
1293                                     X11DRV_DIB_GetNearestIndex
1294                                     (colors, 16,
1295                                      srcbyte[6],
1296                                      srcbyte[5],
1297                                      srcbyte[4]);
1298                         srcbyte+=8;
1299                     }
1300                     if (width&1) {
1301                         /* And then the odd pixel */
1302                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
1303                                     (colors, 16,
1304                                      srcbyte[2],
1305                                      srcbyte[1],
1306                                      srcbyte[0]) << 4);
1307                     }
1308                     srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1309                     dstbits += linebytes;
1310                 }
1311             } else {
1312                 /* ==== bgr 0888 bmp -> pal 4 dib ==== */
1313                 for (h=0; h<lines; h++) {
1314                     srcbyte=srcbits;
1315                     dstbyte=dstbits;
1316                     for (x=0; x<width/2; x++) {
1317                         /* Do 2 pixels at a time */
1318                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
1319                                     (colors, 16,
1320                                      srcbyte[0],
1321                                      srcbyte[1],
1322                                      srcbyte[2]) << 4) |
1323                                     X11DRV_DIB_GetNearestIndex
1324                                     (colors, 16,
1325                                      srcbyte[4],
1326                                      srcbyte[5],
1327                                      srcbyte[6]);
1328                         srcbyte+=8;
1329                     }
1330                     if (width&1) {
1331                         /* And then the odd pixel */
1332                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
1333                                     (colors, 16,
1334                                      srcbyte[0],
1335                                      srcbyte[1],
1336                                      srcbyte[2]) << 4);
1337                     }
1338                     srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1339                     dstbits += linebytes;
1340                 }
1341             }
1342         }
1343         break;
1344
1345     default:
1346     notsupported:
1347         {
1348             BYTE* dstbyte;
1349
1350             /* ==== any bmp format -> pal 4 dib ==== */
1351             WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 4 bit DIB\n",
1352                   bmpImage->bits_per_pixel, bmpImage->red_mask,
1353                   bmpImage->green_mask, bmpImage->blue_mask );
1354             for (h=lines-1; h>=0; h--) {
1355                 dstbyte=dstbits;
1356                 for (x=0; x<(width & ~1); x+=2) {
1357                     *dstbyte++=(X11DRV_DIB_MapColor((int*)colors, 16, XGetPixel(bmpImage, x, h), 0) << 4) |
1358                         X11DRV_DIB_MapColor((int*)colors, 16, XGetPixel(bmpImage, x+1, h), 0);
1359                 }
1360                 if (width & 1) {
1361                     *dstbyte=(X11DRV_DIB_MapColor((int *)colors, 16, XGetPixel(bmpImage, x, h), 0) << 4);
1362                 }
1363                 dstbits += linebytes;
1364             }
1365         }
1366         break;
1367     }
1368 }
1369
1370 /***********************************************************************
1371  *           X11DRV_DIB_SetImageBits_RLE4
1372  *
1373  * SetDIBits for a 4-bit deep compressed DIB.
1374  */
1375 static void X11DRV_DIB_SetImageBits_RLE4( int lines, const BYTE *bits,
1376                                           DWORD srcwidth, DWORD dstwidth,
1377                                           int left, int *colors,
1378                                           XImage *bmpImage )
1379 {
1380     unsigned int x = 0, width = min(srcwidth, dstwidth);
1381     int y = lines - 1, c, length;
1382     const BYTE *begin = bits;
1383
1384     while (y >= 0)
1385     {
1386         length = *bits++;
1387         if (length) {   /* encoded */
1388             c = *bits++;
1389             while (length--) {
1390                 if (x >= (left + width)) break;
1391                 if( x >= left) XPutPixel(bmpImage, x, y, colors[c >> 4]);
1392                 x++;
1393                 if (!length--) break;
1394                 if (x >= (left + width)) break;
1395                 if( x >= left) XPutPixel(bmpImage, x, y, colors[c & 0xf]);
1396                 x++;
1397             }
1398         } else {
1399             length = *bits++;
1400             switch (length)
1401             {
1402             case RLE_EOL:
1403                 x = 0;
1404                 y--;
1405                 break;
1406
1407             case RLE_END:
1408                 return;
1409
1410             case RLE_DELTA:
1411                 x += *bits++;
1412                 y -= *bits++;
1413                 break;
1414
1415             default: /* absolute */
1416                 while (length--) {
1417                     c = *bits++;
1418                     if (x >= left && x < (left + width))
1419                         XPutPixel(bmpImage, x, y, colors[c >> 4]);
1420                     x++;
1421                     if (!length--) break;
1422                     if (x >= left && x < (left + width))
1423                         XPutPixel(bmpImage, x, y, colors[c & 0xf]);
1424                     x++;
1425                 }
1426                 if ((bits - begin) & 1)
1427                     bits++;
1428             }
1429         }
1430     }
1431 }
1432
1433
1434
1435 /***********************************************************************
1436  *           X11DRV_DIB_SetImageBits_8
1437  *
1438  * SetDIBits for an 8-bit deep DIB.
1439  */
1440 static void X11DRV_DIB_SetImageBits_8( int lines, const BYTE *srcbits,
1441                                 DWORD srcwidth, DWORD dstwidth, int left,
1442                                 const int *colors, XImage *bmpImage,
1443                                 int linebytes )
1444 {
1445     DWORD x;
1446     int h, width = min(srcwidth, dstwidth);
1447     const BYTE* srcbyte;
1448     BYTE* dstbits;
1449
1450     if (lines < 0 )
1451     {
1452         lines = -lines;
1453         srcbits = srcbits + linebytes * (lines-1);
1454         linebytes = -linebytes;
1455     }
1456     srcbits += left;
1457     srcbyte = srcbits;
1458
1459     switch (bmpImage->depth) {
1460     case 15:
1461     case 16:
1462         /* Some X servers might have 32 bit/ 16bit deep pixel */
1463         if (lines && width && (bmpImage->bits_per_pixel == 16) &&
1464             (ImageByteOrder(gdi_display)==LSBFirst) )
1465         {
1466             /* ==== pal 8 dib -> rgb or bgr 555 or 565 bmp ==== */
1467             dstbits=(BYTE*)bmpImage->data+left*2+(lines-1)*bmpImage->bytes_per_line;
1468             for (h = lines ; h--; ) {
1469 #if defined(__i386__) && defined(__GNUC__)
1470                 int _cl1,_cl2; /* temp outputs for asm below */
1471                 /* Borrowed from DirectDraw */
1472                 __asm__ __volatile__(
1473                 "xor %%eax,%%eax\n"
1474                 "cld\n"
1475                 "1:\n"
1476                 "    lodsb\n"
1477                 "    movw (%%edx,%%eax,4),%%ax\n"
1478                 "    stosw\n"
1479                 "      xor %%eax,%%eax\n"
1480                 "    loop 1b\n"
1481                 :"=S" (srcbyte), "=D" (_cl1), "=c" (_cl2)
1482                 :"S" (srcbyte),
1483                  "D" (dstbits),
1484                  "c" (width),
1485                  "d" (colors)
1486                 :"eax", "cc", "memory"
1487                 );
1488 #else
1489                 DWORD* dstpixel=(DWORD*)dstbits;
1490                 for (x=0; x<width/2; x++) {
1491                     /* Do 2 pixels at a time */
1492                     *dstpixel++=(colors[srcbyte[1]] << 16) | colors[srcbyte[0]];
1493                     srcbyte+=2;
1494                 }
1495                 if (width&1) {
1496                     /* And then the odd pixel */
1497                     *((WORD*)dstpixel)=colors[srcbyte[0]];
1498                 }
1499 #endif
1500                 srcbyte = (srcbits += linebytes);
1501                 dstbits -= bmpImage->bytes_per_line;
1502             }
1503             return;
1504         }
1505         break;
1506     case 24:
1507     case 32:
1508         if (lines && width && (bmpImage->bits_per_pixel == 32) &&
1509             (ImageByteOrder(gdi_display)==LSBFirst) )
1510         {
1511             dstbits=(BYTE*)bmpImage->data+left*4+(lines-1)*bmpImage->bytes_per_line;
1512             /* ==== pal 8 dib -> rgb or bgr 0888 bmp ==== */
1513             for (h = lines ; h--; ) {
1514 #if defined(__i386__) && defined(__GNUC__)
1515                 int _cl1,_cl2; /* temp outputs for asm below */
1516                 /* Borrowed from DirectDraw */
1517                 __asm__ __volatile__(
1518                 "xor %%eax,%%eax\n"
1519                 "cld\n"
1520                 "1:\n"
1521                 "    lodsb\n"
1522                 "    movl (%%edx,%%eax,4),%%eax\n"
1523                 "    stosl\n"
1524                 "      xor %%eax,%%eax\n"
1525                 "    loop 1b\n"
1526                 :"=S" (srcbyte), "=D" (_cl1), "=c" (_cl2)
1527                 :"S" (srcbyte),
1528                  "D" (dstbits),
1529                  "c" (width),
1530                  "d" (colors)
1531                 :"eax", "cc", "memory"
1532                 );
1533 #else
1534                 DWORD* dstpixel=(DWORD*)dstbits;
1535                 for (x=0; x<width; x++) {
1536                     *dstpixel++=colors[*srcbyte++];
1537                 }
1538 #endif
1539                 srcbyte = (srcbits += linebytes);
1540                 dstbits -= bmpImage->bytes_per_line;
1541             }
1542             return;
1543         }
1544         break;
1545     default:
1546         break; /* use slow generic case below */
1547     }
1548
1549     /* ==== pal 8 dib -> any bmp format ==== */
1550     for (h=lines-1; h>=0; h--) {
1551         for (x=left; x<width+left; x++) {
1552             XPutPixel(bmpImage, x, h, colors[*srcbyte++]);
1553         }
1554         srcbyte = (srcbits += linebytes);
1555     }
1556 }
1557
1558 /***********************************************************************
1559  *           X11DRV_DIB_GetImageBits_8
1560  *
1561  * GetDIBits for an 8-bit deep DIB.
1562  */
1563 static void X11DRV_DIB_GetImageBits_8( int lines, BYTE *dstbits,
1564                                        DWORD srcwidth, DWORD dstwidth,
1565                                        RGBQUAD *colors, PALETTEENTRY *srccolors,
1566                                        XImage *bmpImage, int linebytes )
1567 {
1568     DWORD x;
1569     int h, width = min(srcwidth, dstwidth);
1570     BYTE* dstbyte;
1571
1572     if (lines < 0 )
1573     {
1574        lines = -lines;
1575        dstbits = dstbits + ( linebytes * (lines-1) );
1576        linebytes = -linebytes;
1577     }
1578
1579     /*
1580      * Hack for now
1581      * This condition is true when GetImageBits has been called by
1582      * UpdateDIBSection. For now, GetNearestIndex is too slow to support
1583      * 256 colormaps, so we'll just use it for GetDIBits calls.
1584      * (In some cases, in an updateDIBSection, the returned colors are bad too)
1585      */
1586     if (!srccolors) goto updatesection;
1587
1588     switch (bmpImage->depth) {
1589     case 1:
1590     case 4:
1591         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
1592             && srccolors) {
1593
1594             /* ==== pal 1 bmp -> pal 8 dib ==== */
1595             /* ==== pal 4 bmp -> pal 8 dib ==== */
1596             for (h=lines-1; h>=0; h--) {
1597                 dstbyte=dstbits;
1598                 for (x=0; x<width; x++) {
1599                     PALETTEENTRY srcval;
1600                     srcval=srccolors[XGetPixel(bmpImage, x, h)];
1601                     *dstbyte++=X11DRV_DIB_GetNearestIndex(colors, 256,
1602                                                           srcval.peRed,
1603                                                           srcval.peGreen,
1604                                                           srcval.peBlue);
1605                 }
1606                 dstbits += linebytes;
1607             }
1608         } else {
1609             goto notsupported;
1610         }
1611         break;
1612
1613     case 8:
1614        if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
1615            && srccolors) {
1616             /* ==== pal 8 bmp -> pal 8 dib ==== */
1617            const void* srcbits;
1618            const BYTE* srcpixel;
1619
1620            srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1621            for (h=0; h<lines; h++) {
1622                srcpixel=srcbits;
1623                dstbyte=dstbits;
1624                for (x = 0; x < width; x++) {
1625                    PALETTEENTRY srcval;
1626                    srcval=srccolors[*srcpixel++];
1627                    *dstbyte++=X11DRV_DIB_GetNearestIndex(colors, 256,
1628                                                          srcval.peRed,
1629                                                          srcval.peGreen,
1630                                                          srcval.peBlue);
1631                }
1632                srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1633                dstbits += linebytes;
1634            }
1635        } else {
1636            goto notsupported;
1637        }
1638        break;
1639
1640     case 15:
1641     case 16:
1642         {
1643             const void* srcbits;
1644             const WORD* srcpixel;
1645             BYTE* dstbyte;
1646
1647             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1648
1649             if (bmpImage->green_mask==0x03e0) {
1650                 if (bmpImage->red_mask==0x7c00) {
1651                     /* ==== rgb 555 bmp -> pal 8 dib ==== */
1652                     for (h=0; h<lines; h++) {
1653                         srcpixel=srcbits;
1654                         dstbyte=dstbits;
1655                         for (x=0; x<width; x++) {
1656                             WORD srcval;
1657                             srcval=*srcpixel++;
1658                             *dstbyte++=X11DRV_DIB_GetNearestIndex
1659                                 (colors, 256,
1660                                  ((srcval >>  7) & 0xf8) | /* r */
1661                                  ((srcval >> 12) & 0x07),
1662                                  ((srcval >>  2) & 0xf8) | /* g */
1663                                  ((srcval >>  7) & 0x07),
1664                                  ((srcval <<  3) & 0xf8) | /* b */
1665                                  ((srcval >>  2) & 0x07) );
1666                         }
1667                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1668                         dstbits += linebytes;
1669                     }
1670                 } else if (bmpImage->blue_mask==0x7c00) {
1671                     /* ==== bgr 555 bmp -> pal 8 dib ==== */
1672                     for (h=0; h<lines; h++) {
1673                         srcpixel=srcbits;
1674                         dstbyte=dstbits;
1675                         for (x=0; x<width; x++) {
1676                             WORD srcval;
1677                             srcval=*srcpixel++;
1678                             *dstbyte++=X11DRV_DIB_GetNearestIndex
1679                                 (colors, 256,
1680                                  ((srcval <<  3) & 0xf8) | /* r */
1681                                  ((srcval >>  2) & 0x07),
1682                                  ((srcval >>  2) & 0xf8) | /* g */
1683                                  ((srcval >>  7) & 0x07),
1684                                  ((srcval >>  7) & 0xf8) | /* b */
1685                                  ((srcval >> 12) & 0x07) );
1686                         }
1687                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1688                         dstbits += linebytes;
1689                     }
1690                 } else {
1691                     goto notsupported;
1692                 }
1693             } else if (bmpImage->green_mask==0x07e0) {
1694                 if (bmpImage->red_mask==0xf800) {
1695                     /* ==== rgb 565 bmp -> pal 8 dib ==== */
1696                     for (h=0; h<lines; h++) {
1697                         srcpixel=srcbits;
1698                         dstbyte=dstbits;
1699                         for (x=0; x<width; x++) {
1700                             WORD srcval;
1701                             srcval=*srcpixel++;
1702                             *dstbyte++=X11DRV_DIB_GetNearestIndex
1703                                 (colors, 256,
1704                                  ((srcval >>  8) & 0xf8) | /* r */
1705                                  ((srcval >> 13) & 0x07),
1706                                  ((srcval >>  3) & 0xfc) | /* g */
1707                                  ((srcval >>  9) & 0x03),
1708                                  ((srcval <<  3) & 0xf8) | /* b */
1709                                  ((srcval >>  2) & 0x07) );
1710                         }
1711                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1712                         dstbits += linebytes;
1713                     }
1714                 } else if (bmpImage->blue_mask==0xf800) {
1715                     /* ==== bgr 565 bmp -> pal 8 dib ==== */
1716                     for (h=0; h<lines; h++) {
1717                         srcpixel=srcbits;
1718                         dstbyte=dstbits;
1719                         for (x=0; x<width; x++) {
1720                             WORD srcval;
1721                             srcval=*srcpixel++;
1722                             *dstbyte++=X11DRV_DIB_GetNearestIndex
1723                                 (colors, 256,
1724                                  ((srcval <<  3) & 0xf8) | /* r */
1725                                  ((srcval >>  2) & 0x07),
1726                                  ((srcval >>  3) & 0xfc) | /* g */
1727                                  ((srcval >>  9) & 0x03),
1728                                  ((srcval >>  8) & 0xf8) | /* b */
1729                                  ((srcval >> 13) & 0x07) );
1730                         }
1731                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1732                         dstbits += linebytes;
1733                     }
1734                 } else {
1735                     goto notsupported;
1736                 }
1737             } else {
1738                 goto notsupported;
1739             }
1740         }
1741         break;
1742
1743     case 24:
1744     case 32:
1745         {
1746             const void* srcbits;
1747             const BYTE *srcbyte;
1748             BYTE* dstbyte;
1749             int bytes_per_pixel;
1750
1751             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1752             bytes_per_pixel=(bmpImage->bits_per_pixel==24?3:4);
1753
1754             if (bmpImage->green_mask!=0x00ff00 ||
1755                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
1756                 goto notsupported;
1757             } else if (bmpImage->blue_mask==0xff) {
1758                 /* ==== rgb 888 or 0888 bmp -> pal 8 dib ==== */
1759                 for (h=0; h<lines; h++) {
1760                     srcbyte=srcbits;
1761                     dstbyte=dstbits;
1762                     for (x=0; x<width; x++) {
1763                         *dstbyte++=X11DRV_DIB_GetNearestIndex
1764                             (colors, 256,
1765                              srcbyte[2],
1766                              srcbyte[1],
1767                              srcbyte[0]);
1768                         srcbyte+=bytes_per_pixel;
1769                     }
1770                     srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1771                     dstbits += linebytes;
1772                 }
1773             } else {
1774                 /* ==== bgr 888 or 0888 bmp -> pal 8 dib ==== */
1775                 for (h=0; h<lines; h++) {
1776                     srcbyte=srcbits;
1777                     dstbyte=dstbits;
1778                     for (x=0; x<width; x++) {
1779                         *dstbyte++=X11DRV_DIB_GetNearestIndex
1780                             (colors, 256,
1781                              srcbyte[0],
1782                              srcbyte[1],
1783                              srcbyte[2]);
1784                         srcbyte+=bytes_per_pixel;
1785                     }
1786                     srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1787                     dstbits += linebytes;
1788                 }
1789             }
1790         }
1791         break;
1792
1793     default:
1794     notsupported:
1795         WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 8 bit DIB\n",
1796               bmpImage->depth, bmpImage->red_mask,
1797               bmpImage->green_mask, bmpImage->blue_mask );
1798     updatesection:
1799         /* ==== any bmp format -> pal 8 dib ==== */
1800         for (h=lines-1; h>=0; h--) {
1801             dstbyte=dstbits;
1802             for (x=0; x<width; x++) {
1803                 *dstbyte=X11DRV_DIB_MapColor
1804                     ((int*)colors, 256,
1805                      XGetPixel(bmpImage, x, h), *dstbyte);
1806                 dstbyte++;
1807             }
1808             dstbits += linebytes;
1809         }
1810         break;
1811     }
1812 }
1813
1814 /***********************************************************************
1815  *            X11DRV_DIB_SetImageBits_RLE8
1816  *
1817  * SetDIBits for an 8-bit deep compressed DIB.
1818  *
1819  * This function rewritten 941113 by James Youngman.  WINE blew out when I
1820  * first ran it because my desktop wallpaper is a (large) RLE8 bitmap.
1821  *
1822  * This was because the algorithm assumed that all RLE8 bitmaps end with the
1823  * 'End of bitmap' escape code.  This code is very much laxer in what it
1824  * allows to end the expansion.  Possibly too lax.  See the note by
1825  * case RleDelta.  BTW, MS's documentation implies that a correct RLE8
1826  * bitmap should end with RleEnd, but on the other hand, software exists
1827  * that produces ones that don't and Windows 3.1 doesn't complain a bit
1828  * about it.
1829  *
1830  * (No) apologies for my English spelling.  [Emacs users: c-indent-level=4].
1831  *                      James A. Youngman <mbcstjy@afs.man.ac.uk>
1832  *                                              [JAY]
1833  */
1834 static void X11DRV_DIB_SetImageBits_RLE8( int lines, const BYTE *bits,
1835                                           DWORD srcwidth, DWORD dstwidth,
1836                                           int left, int *colors,
1837                                           XImage *bmpImage )
1838 {
1839     unsigned int x;             /* X-position on each line.  Increases. */
1840     int y;                      /* Line #.  Starts at lines-1, decreases */
1841     const BYTE *pIn = bits;     /* Pointer to current position in bits */
1842     BYTE length;                /* The length pf a run */
1843     BYTE escape_code;           /* See enum Rle8_EscapeCodes.*/
1844
1845     /*
1846      * Note that the bitmap data is stored by Windows starting at the
1847      * bottom line of the bitmap and going upwards.  Within each line,
1848      * the data is stored left-to-right.  That's the reason why line
1849      * goes from lines-1 to 0.                  [JAY]
1850      */
1851
1852     x = 0;
1853     y = lines - 1;
1854     while (y >= 0)
1855     {
1856         length = *pIn++;
1857
1858         /*
1859          * If the length byte is not zero (which is the escape value),
1860          * We have a run of length pixels all the same colour.  The colour
1861          * index is stored next.
1862          *
1863          * If the length byte is zero, we need to read the next byte to
1864          * know what to do.                     [JAY]
1865          */
1866         if (length != 0)
1867         {
1868             /*
1869              * [Run-Length] Encoded mode
1870              */
1871             int color = colors[*pIn++];
1872             while (length-- && x < (left + dstwidth)) {
1873                 if( x >= left) XPutPixel(bmpImage, x, y, color);
1874                 x++;
1875             }
1876         }
1877         else
1878         {
1879             /*
1880              * Escape codes (may be an absolute sequence though)
1881              */
1882             escape_code = (*pIn++);
1883             switch(escape_code)
1884             {
1885             case RLE_EOL:
1886                 x = 0;
1887                 y--;
1888                 break;
1889
1890             case RLE_END:
1891                 /* Not all RLE8 bitmaps end with this code.  For
1892                  * example, Paint Shop Pro produces some that don't.
1893                  * That's (I think) what caused the previous
1894                  * implementation to fail.  [JAY]
1895                  */
1896                 return;
1897
1898             case RLE_DELTA:
1899                 x += (*pIn++);
1900                 y -= (*pIn++);
1901                 break;
1902
1903             default:  /* switch to absolute mode */
1904                 length = escape_code;
1905                 while (length--)
1906                 {
1907                     int color = colors[*pIn++];
1908                     if (x >= (left + dstwidth))
1909                     {
1910                         pIn += length;
1911                         break;
1912                     }
1913                     if( x >= left) XPutPixel(bmpImage, x, y, color);
1914                     x++;
1915                 }
1916                 /*
1917                  * If you think for a moment you'll realise that the
1918                  * only time we could ever possibly read an odd
1919                  * number of bytes is when there is a 0x00 (escape),
1920                  * a value >0x02 (absolute mode) and then an odd-
1921                  * length run.  Therefore this is the only place we
1922                  * need to worry about it.  Everywhere else the
1923                  * bytes are always read in pairs.  [JAY]
1924                  */
1925                 if (escape_code & 1) pIn++; /* Throw away the pad byte. */
1926                 break;
1927             } /* switch (escape_code) : Escape sequence */
1928         }
1929     }
1930 }
1931
1932
1933 /***********************************************************************
1934  *           X11DRV_DIB_SetImageBits_16
1935  *
1936  * SetDIBits for a 16-bit deep DIB.
1937  */
1938 static void X11DRV_DIB_SetImageBits_16( int lines, const BYTE *srcbits,
1939                                         DWORD srcwidth, DWORD dstwidth, int left,
1940                                         X11DRV_PDEVICE *physDev, DWORD rSrc, DWORD gSrc, DWORD bSrc,
1941                                         XImage *bmpImage, int linebytes )
1942 {
1943     DWORD x;
1944     int h, width = min(srcwidth, dstwidth);
1945     const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_dst_byteswap;
1946
1947     if (lines < 0 )
1948     {
1949         lines = -lines;
1950         srcbits = srcbits + ( linebytes * (lines-1));
1951         linebytes = -linebytes;
1952     }
1953
1954     switch (bmpImage->depth)
1955     {
1956     case 15:
1957     case 16:
1958         {
1959             char* dstbits;
1960
1961             srcbits=srcbits+left*2;
1962             dstbits=bmpImage->data+left*2+(lines-1)*bmpImage->bytes_per_line;
1963
1964             if (bmpImage->green_mask==0x03e0) {
1965                 if (gSrc==bmpImage->green_mask) {
1966                     if (rSrc==bmpImage->red_mask) {
1967                         /* ==== rgb 555 dib -> rgb 555 bmp ==== */
1968                         /* ==== bgr 555 dib -> bgr 555 bmp ==== */
1969                         convs->Convert_5x5_asis
1970                             (width,lines,
1971                              srcbits,linebytes,
1972                              dstbits,-bmpImage->bytes_per_line);
1973                     } else if (rSrc==bmpImage->blue_mask) {
1974                         /* ==== rgb 555 dib -> bgr 555 bmp ==== */
1975                         /* ==== bgr 555 dib -> rgb 555 bmp ==== */
1976                         convs->Convert_555_reverse
1977                             (width,lines,
1978                              srcbits,linebytes,
1979                              dstbits,-bmpImage->bytes_per_line);
1980                     }
1981                 } else {
1982                     if (rSrc==bmpImage->red_mask || bSrc==bmpImage->blue_mask) {
1983                         /* ==== rgb 565 dib -> rgb 555 bmp ==== */
1984                         /* ==== bgr 565 dib -> bgr 555 bmp ==== */
1985                         convs->Convert_565_to_555_asis
1986                             (width,lines,
1987                              srcbits,linebytes,
1988                              dstbits,-bmpImage->bytes_per_line);
1989                     } else {
1990                         /* ==== rgb 565 dib -> bgr 555 bmp ==== */
1991                         /* ==== bgr 565 dib -> rgb 555 bmp ==== */
1992                         convs->Convert_565_to_555_reverse
1993                             (width,lines,
1994                              srcbits,linebytes,
1995                              dstbits,-bmpImage->bytes_per_line);
1996                     }
1997                 }
1998             } else if (bmpImage->green_mask==0x07e0) {
1999                 if (gSrc==bmpImage->green_mask) {
2000                     if (rSrc==bmpImage->red_mask) {
2001                         /* ==== rgb 565 dib -> rgb 565 bmp ==== */
2002                         /* ==== bgr 565 dib -> bgr 565 bmp ==== */
2003                         convs->Convert_5x5_asis
2004                             (width,lines,
2005                              srcbits,linebytes,
2006                              dstbits,-bmpImage->bytes_per_line);
2007                     } else {
2008                         /* ==== rgb 565 dib -> bgr 565 bmp ==== */
2009                         /* ==== bgr 565 dib -> rgb 565 bmp ==== */
2010                         convs->Convert_565_reverse
2011                             (width,lines,
2012                              srcbits,linebytes,
2013                              dstbits,-bmpImage->bytes_per_line);
2014                     }
2015                 } else {
2016                     if (rSrc==bmpImage->red_mask || bSrc==bmpImage->blue_mask) {
2017                         /* ==== rgb 555 dib -> rgb 565 bmp ==== */
2018                         /* ==== bgr 555 dib -> bgr 565 bmp ==== */
2019                         convs->Convert_555_to_565_asis
2020                             (width,lines,
2021                              srcbits,linebytes,
2022                              dstbits,-bmpImage->bytes_per_line);
2023                     } else {
2024                         /* ==== rgb 555 dib -> bgr 565 bmp ==== */
2025                         /* ==== bgr 555 dib -> rgb 565 bmp ==== */
2026                         convs->Convert_555_to_565_reverse
2027                             (width,lines,
2028                              srcbits,linebytes,
2029                              dstbits,-bmpImage->bytes_per_line);
2030                     }
2031                 }
2032             } else {
2033                 goto notsupported;
2034             }
2035         }
2036         break;
2037
2038     case 24:
2039         if (bmpImage->bits_per_pixel==24) {
2040             char* dstbits;
2041
2042             srcbits=srcbits+left*2;
2043             dstbits=bmpImage->data+left*3+(lines-1)*bmpImage->bytes_per_line;
2044
2045             if (bmpImage->green_mask!=0x00ff00 ||
2046                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2047                 goto notsupported;
2048             } else if ((rSrc==0x1f && bmpImage->red_mask==0xff) ||
2049                        (bSrc==0x1f && bmpImage->blue_mask==0xff)) {
2050                 if (gSrc==0x03e0) {
2051                     /* ==== rgb 555 dib -> rgb 888 bmp ==== */
2052                     /* ==== bgr 555 dib -> bgr 888 bmp ==== */
2053                     convs->Convert_555_to_888_asis
2054                         (width,lines,
2055                          srcbits,linebytes,
2056                          dstbits,-bmpImage->bytes_per_line);
2057                 } else {
2058                     /* ==== rgb 565 dib -> rgb 888 bmp ==== */
2059                     /* ==== bgr 565 dib -> bgr 888 bmp ==== */
2060                     convs->Convert_565_to_888_asis
2061                         (width,lines,
2062                          srcbits,linebytes,
2063                          dstbits,-bmpImage->bytes_per_line);
2064                 }
2065             } else {
2066                 if (gSrc==0x03e0) {
2067                     /* ==== rgb 555 dib -> bgr 888 bmp ==== */
2068                     /* ==== bgr 555 dib -> rgb 888 bmp ==== */
2069                     convs->Convert_555_to_888_reverse
2070                         (width,lines,
2071                          srcbits,linebytes,
2072                          dstbits,-bmpImage->bytes_per_line);
2073                 } else {
2074                     /* ==== rgb 565 dib -> bgr 888 bmp ==== */
2075                     /* ==== bgr 565 dib -> rgb 888 bmp ==== */
2076                     convs->Convert_565_to_888_reverse
2077                         (width,lines,
2078                          srcbits,linebytes,
2079                          dstbits,-bmpImage->bytes_per_line);
2080                 }
2081             }
2082             break;
2083         }
2084         /* Fall through */
2085
2086     case 32:
2087         {
2088             char* dstbits;
2089
2090             srcbits=srcbits+left*2;
2091             dstbits=bmpImage->data+left*4+(lines-1)*bmpImage->bytes_per_line;
2092
2093             if (bmpImage->green_mask!=0x00ff00 ||
2094                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2095                 goto notsupported;
2096             } else if ((rSrc==0x1f && bmpImage->red_mask==0xff) ||
2097                        (bSrc==0x1f && bmpImage->blue_mask==0xff)) {
2098                 if (gSrc==0x03e0) {
2099                     /* ==== rgb 555 dib -> rgb 0888 bmp ==== */
2100                     /* ==== bgr 555 dib -> bgr 0888 bmp ==== */
2101                     convs->Convert_555_to_0888_asis
2102                         (width,lines,
2103                          srcbits,linebytes,
2104                          dstbits,-bmpImage->bytes_per_line);
2105                 } else {
2106                     /* ==== rgb 565 dib -> rgb 0888 bmp ==== */
2107                     /* ==== bgr 565 dib -> bgr 0888 bmp ==== */
2108                     convs->Convert_565_to_0888_asis
2109                         (width,lines,
2110                          srcbits,linebytes,
2111                          dstbits,-bmpImage->bytes_per_line);
2112                 }
2113             } else {
2114                 if (gSrc==0x03e0) {
2115                     /* ==== rgb 555 dib -> bgr 0888 bmp ==== */
2116                     /* ==== bgr 555 dib -> rgb 0888 bmp ==== */
2117                     convs->Convert_555_to_0888_reverse
2118                         (width,lines,
2119                          srcbits,linebytes,
2120                          dstbits,-bmpImage->bytes_per_line);
2121                 } else {
2122                     /* ==== rgb 565 dib -> bgr 0888 bmp ==== */
2123                     /* ==== bgr 565 dib -> rgb 0888 bmp ==== */
2124                     convs->Convert_565_to_0888_reverse
2125                         (width,lines,
2126                          srcbits,linebytes,
2127                          dstbits,-bmpImage->bytes_per_line);
2128                 }
2129             }
2130         }
2131         break;
2132
2133     default:
2134     notsupported:
2135         WARN("from 16 bit DIB (%x,%x,%x) to unknown %d bit bitmap (%lx,%lx,%lx)\n",
2136               rSrc, gSrc, bSrc, bmpImage->bits_per_pixel, bmpImage->red_mask,
2137               bmpImage->green_mask, bmpImage->blue_mask );
2138         /* fall through */
2139     case 1:
2140     case 4:
2141     case 8:
2142         {
2143             /* ==== rgb or bgr 555 or 565 dib -> pal 1, 4 or 8 ==== */
2144             const WORD* srcpixel;
2145             int rShift1,gShift1,bShift1;
2146             int rShift2,gShift2,bShift2;
2147             BYTE gMask1,gMask2;
2148
2149             /* Set color scaling values */
2150             rShift1=16+X11DRV_DIB_MaskToShift(rSrc)-3;
2151             gShift1=16+X11DRV_DIB_MaskToShift(gSrc)-3;
2152             bShift1=16+X11DRV_DIB_MaskToShift(bSrc)-3;
2153             rShift2=rShift1+5;
2154             gShift2=gShift1+5;
2155             bShift2=bShift1+5;
2156             if (gSrc==0x03e0) {
2157                 /* Green has 5 bits, like the others */
2158                 gMask1=0xf8;
2159                 gMask2=0x07;
2160             } else {
2161                 /* Green has 6 bits, not 5. Compensate. */
2162                 gShift1++;
2163                 gShift2+=2;
2164                 gMask1=0xfc;
2165                 gMask2=0x03;
2166             }
2167
2168             srcbits+=2*left;
2169
2170             /* We could split it into four separate cases to optimize
2171              * but it is probably not worth it.
2172              */
2173             for (h=lines-1; h>=0; h--) {
2174                 srcpixel=(const WORD*)srcbits;
2175                 for (x=left; x<width+left; x++) {
2176                     DWORD srcval;
2177                     BYTE red,green,blue;
2178                     srcval=*srcpixel++ << 16;
2179                     red=  ((srcval >> rShift1) & 0xf8) |
2180                         ((srcval >> rShift2) & 0x07);
2181                     green=((srcval >> gShift1) & gMask1) |
2182                         ((srcval >> gShift2) & gMask2);
2183                     blue= ((srcval >> bShift1) & 0xf8) |
2184                         ((srcval >> bShift2) & 0x07);
2185                     XPutPixel(bmpImage, x, h,
2186                               X11DRV_PALETTE_ToPhysical
2187                               (physDev, RGB(red,green,blue)));
2188                 }
2189                 srcbits += linebytes;
2190             }
2191         }
2192         break;
2193     }
2194 }
2195
2196
2197 /***********************************************************************
2198  *           X11DRV_DIB_GetImageBits_16
2199  *
2200  * GetDIBits for an 16-bit deep DIB.
2201  */
2202 static void X11DRV_DIB_GetImageBits_16( X11DRV_PDEVICE *physDev, int lines, BYTE *dstbits,
2203                                         DWORD dstwidth, DWORD srcwidth,
2204                                         PALETTEENTRY *srccolors,
2205                                         DWORD rDst, DWORD gDst, DWORD bDst,
2206                                         XImage *bmpImage, int linebytes )
2207 {
2208     DWORD x;
2209     int h, width = min(srcwidth, dstwidth);
2210     const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_src_byteswap;
2211
2212     if (lines < 0 )
2213     {
2214         lines = -lines;
2215         dstbits = dstbits + ( linebytes * (lines-1));
2216         linebytes = -linebytes;
2217     }
2218
2219     switch (bmpImage->depth)
2220     {
2221     case 15:
2222     case 16:
2223         {
2224             const char* srcbits;
2225
2226             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2227
2228             if (bmpImage->green_mask==0x03e0) {
2229                 if (gDst==bmpImage->green_mask) {
2230                     if (rDst==bmpImage->red_mask) {
2231                         /* ==== rgb 555 bmp -> rgb 555 dib ==== */
2232                         /* ==== bgr 555 bmp -> bgr 555 dib ==== */
2233                         convs->Convert_5x5_asis
2234                             (width,lines,
2235                              srcbits,-bmpImage->bytes_per_line,
2236                              dstbits,linebytes);
2237                     } else {
2238                         /* ==== rgb 555 bmp -> bgr 555 dib ==== */
2239                         /* ==== bgr 555 bmp -> rgb 555 dib ==== */
2240                         convs->Convert_555_reverse
2241                             (width,lines,
2242                              srcbits,-bmpImage->bytes_per_line,
2243                              dstbits,linebytes);
2244                     }
2245                 } else {
2246                     if (rDst==bmpImage->red_mask || bDst==bmpImage->blue_mask) {
2247                         /* ==== rgb 555 bmp -> rgb 565 dib ==== */
2248                         /* ==== bgr 555 bmp -> bgr 565 dib ==== */
2249                         convs->Convert_555_to_565_asis
2250                             (width,lines,
2251                              srcbits,-bmpImage->bytes_per_line,
2252                              dstbits,linebytes);
2253                     } else {
2254                         /* ==== rgb 555 bmp -> bgr 565 dib ==== */
2255                         /* ==== bgr 555 bmp -> rgb 565 dib ==== */
2256                         convs->Convert_555_to_565_reverse
2257                             (width,lines,
2258                              srcbits,-bmpImage->bytes_per_line,
2259                              dstbits,linebytes);
2260                     }
2261                 }
2262             } else if (bmpImage->green_mask==0x07e0) {
2263                 if (gDst==bmpImage->green_mask) {
2264                     if (rDst == bmpImage->red_mask) {
2265                         /* ==== rgb 565 bmp -> rgb 565 dib ==== */
2266                         /* ==== bgr 565 bmp -> bgr 565 dib ==== */
2267                         convs->Convert_5x5_asis
2268                             (width,lines,
2269                              srcbits,-bmpImage->bytes_per_line,
2270                              dstbits,linebytes);
2271                     } else {
2272                         /* ==== rgb 565 bmp -> bgr 565 dib ==== */
2273                         /* ==== bgr 565 bmp -> rgb 565 dib ==== */
2274                         convs->Convert_565_reverse
2275                             (width,lines,
2276                              srcbits,-bmpImage->bytes_per_line,
2277                              dstbits,linebytes);
2278                     }
2279                 } else {
2280                     if (rDst==bmpImage->red_mask || bDst==bmpImage->blue_mask) {
2281                         /* ==== rgb 565 bmp -> rgb 555 dib ==== */
2282                         /* ==== bgr 565 bmp -> bgr 555 dib ==== */
2283                         convs->Convert_565_to_555_asis
2284                             (width,lines,
2285                              srcbits,-bmpImage->bytes_per_line,
2286                              dstbits,linebytes);
2287                     } else {
2288                         /* ==== rgb 565 bmp -> bgr 555 dib ==== */
2289                         /* ==== bgr 565 bmp -> rgb 555 dib ==== */
2290                         convs->Convert_565_to_555_reverse
2291                             (width,lines,
2292                              srcbits,-bmpImage->bytes_per_line,
2293                              dstbits,linebytes);
2294                     }
2295                 }
2296             } else {
2297                 goto notsupported;
2298             }
2299         }
2300         break;
2301
2302     case 24:
2303         if (bmpImage->bits_per_pixel == 24) {
2304             const char* srcbits;
2305
2306             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2307
2308             if (bmpImage->green_mask!=0x00ff00 ||
2309                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2310                 goto notsupported;
2311             } else if ((rDst==0x1f && bmpImage->red_mask==0xff) ||
2312                     (bDst==0x1f && bmpImage->blue_mask==0xff)) {
2313                 if (gDst==0x03e0) {
2314                     /* ==== rgb 888 bmp -> rgb 555 dib ==== */
2315                     /* ==== bgr 888 bmp -> bgr 555 dib ==== */
2316                     convs->Convert_888_to_555_asis
2317                         (width,lines,
2318                          srcbits,-bmpImage->bytes_per_line,
2319                          dstbits,linebytes);
2320                 } else {
2321                     /* ==== rgb 888 bmp -> rgb 565 dib ==== */
2322                     /* ==== rgb 888 bmp -> rgb 565 dib ==== */
2323                     convs->Convert_888_to_565_asis
2324                         (width,lines,
2325                          srcbits,-bmpImage->bytes_per_line,
2326                          dstbits,linebytes);
2327                 }
2328             } else {
2329                 if (gDst==0x03e0) {
2330                     /* ==== rgb 888 bmp -> bgr 555 dib ==== */
2331                     /* ==== bgr 888 bmp -> rgb 555 dib ==== */
2332                     convs->Convert_888_to_555_reverse
2333                         (width,lines,
2334                          srcbits,-bmpImage->bytes_per_line,
2335                          dstbits,linebytes);
2336                 } else {
2337                     /* ==== rgb 888 bmp -> bgr 565 dib ==== */
2338                     /* ==== bgr 888 bmp -> rgb 565 dib ==== */
2339                     convs->Convert_888_to_565_reverse
2340                         (width,lines,
2341                          srcbits,-bmpImage->bytes_per_line,
2342                          dstbits,linebytes);
2343                 }
2344             }
2345             break;
2346         }
2347         /* Fall through */
2348
2349     case 32:
2350         {
2351             const char* srcbits;
2352
2353             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2354
2355             if (bmpImage->green_mask!=0x00ff00 ||
2356                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2357                 goto notsupported;
2358             } else if ((rDst==0x1f && bmpImage->red_mask==0xff) ||
2359                        (bDst==0x1f && bmpImage->blue_mask==0xff)) {
2360                 if (gDst==0x03e0) {
2361                     /* ==== rgb 0888 bmp -> rgb 555 dib ==== */
2362                     /* ==== bgr 0888 bmp -> bgr 555 dib ==== */
2363                     convs->Convert_0888_to_555_asis
2364                         (width,lines,
2365                          srcbits,-bmpImage->bytes_per_line,
2366                          dstbits,linebytes);
2367                 } else {
2368                     /* ==== rgb 0888 bmp -> rgb 565 dib ==== */
2369                     /* ==== bgr 0888 bmp -> bgr 565 dib ==== */
2370                     convs->Convert_0888_to_565_asis
2371                         (width,lines,
2372                          srcbits,-bmpImage->bytes_per_line,
2373                          dstbits,linebytes);
2374                 }
2375             } else {
2376                 if (gDst==0x03e0) {
2377                     /* ==== rgb 0888 bmp -> bgr 555 dib ==== */
2378                     /* ==== bgr 0888 bmp -> rgb 555 dib ==== */
2379                     convs->Convert_0888_to_555_reverse
2380                         (width,lines,
2381                          srcbits,-bmpImage->bytes_per_line,
2382                          dstbits,linebytes);
2383                 } else {
2384                     /* ==== rgb 0888 bmp -> bgr 565 dib ==== */
2385                     /* ==== bgr 0888 bmp -> rgb 565 dib ==== */
2386                     convs->Convert_0888_to_565_reverse
2387                         (width,lines,
2388                          srcbits,-bmpImage->bytes_per_line,
2389                          dstbits,linebytes);
2390                 }
2391             }
2392         }
2393         break;
2394
2395     case 1:
2396     case 4:
2397         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
2398             && srccolors) {
2399             /* ==== pal 1 or 4 bmp -> rgb or bgr 555 or 565 dib ==== */
2400             int rShift,gShift,bShift;
2401             WORD* dstpixel;
2402
2403             /* Shift everything 16 bits left so that all shifts are >0,
2404              * even for BGR DIBs. Then a single >> 16 will bring everything
2405              * back into place.
2406              */
2407             rShift=16+X11DRV_DIB_MaskToShift(rDst)-3;
2408             gShift=16+X11DRV_DIB_MaskToShift(gDst)-3;
2409             bShift=16+X11DRV_DIB_MaskToShift(bDst)-3;
2410             if (gDst==0x07e0) {
2411                 /* 6 bits for the green */
2412                 gShift++;
2413             }
2414             rDst=rDst << 16;
2415             gDst=gDst << 16;
2416             bDst=bDst << 16;
2417             for (h = lines - 1; h >= 0; h--) {
2418                 dstpixel=(LPWORD)dstbits;
2419                 for (x = 0; x < width; x++) {
2420                     PALETTEENTRY srcval;
2421                     DWORD dstval;
2422                     srcval=srccolors[XGetPixel(bmpImage, x, h)];
2423                     dstval=((srcval.peRed   << rShift) & rDst) |
2424                            ((srcval.peGreen << gShift) & gDst) |
2425                            ((srcval.peBlue  << bShift) & bDst);
2426                     *dstpixel++=dstval >> 16;
2427                 }
2428                 dstbits += linebytes;
2429             }
2430         } else {
2431             goto notsupported;
2432         }
2433         break;
2434
2435     case 8:
2436         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
2437             && srccolors) {
2438             /* ==== pal 8 bmp -> rgb or bgr 555 or 565 dib ==== */
2439             int rShift,gShift,bShift;
2440             const BYTE* srcbits;
2441             const BYTE* srcpixel;
2442             WORD* dstpixel;
2443
2444             /* Shift everything 16 bits left so that all shifts are >0,
2445              * even for BGR DIBs. Then a single >> 16 will bring everything
2446              * back into place.
2447              */
2448             rShift=16+X11DRV_DIB_MaskToShift(rDst)-3;
2449             gShift=16+X11DRV_DIB_MaskToShift(gDst)-3;
2450             bShift=16+X11DRV_DIB_MaskToShift(bDst)-3;
2451             if (gDst==0x07e0) {
2452                 /* 6 bits for the green */
2453                 gShift++;
2454             }
2455             rDst=rDst << 16;
2456             gDst=gDst << 16;
2457             bDst=bDst << 16;
2458             srcbits=(BYTE*)bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2459             for (h=0; h<lines; h++) {
2460                 srcpixel=srcbits;
2461                 dstpixel=(LPWORD)dstbits;
2462                 for (x = 0; x < width; x++) {
2463                     PALETTEENTRY srcval;
2464                     DWORD dstval;
2465                     srcval=srccolors[*srcpixel++];
2466                     dstval=((srcval.peRed   << rShift) & rDst) |
2467                            ((srcval.peGreen << gShift) & gDst) |
2468                            ((srcval.peBlue  << bShift) & bDst);
2469                     *dstpixel++=dstval >> 16;
2470                 }
2471                 srcbits -= bmpImage->bytes_per_line;
2472                 dstbits += linebytes;
2473             }
2474         } else {
2475             goto notsupported;
2476         }
2477         break;
2478
2479     default:
2480     notsupported:
2481         {
2482             /* ==== any bmp format -> rgb or bgr 555 or 565 dib ==== */
2483             int rShift,gShift,bShift;
2484             WORD* dstpixel;
2485
2486             WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 16 bit DIB (%x,%x,%x)\n",
2487                   bmpImage->depth, bmpImage->red_mask,
2488                   bmpImage->green_mask, bmpImage->blue_mask,
2489                   rDst, gDst, bDst);
2490
2491             /* Shift everything 16 bits left so that all shifts are >0,
2492              * even for BGR DIBs. Then a single >> 16 will bring everything
2493              * back into place.
2494              */
2495             rShift=16+X11DRV_DIB_MaskToShift(rDst)-3;
2496             gShift=16+X11DRV_DIB_MaskToShift(gDst)-3;
2497             bShift=16+X11DRV_DIB_MaskToShift(bDst)-3;
2498             if (gDst==0x07e0) {
2499                 /* 6 bits for the green */
2500                 gShift++;
2501             }
2502             rDst=rDst << 16;
2503             gDst=gDst << 16;
2504             bDst=bDst << 16;
2505             for (h = lines - 1; h >= 0; h--) {
2506                 dstpixel=(LPWORD)dstbits;
2507                 for (x = 0; x < width; x++) {
2508                     COLORREF srcval;
2509                     DWORD dstval;
2510                     srcval=X11DRV_PALETTE_ToLogical(physDev, XGetPixel(bmpImage, x, h));
2511                     dstval=((GetRValue(srcval) << rShift) & rDst) |
2512                            ((GetGValue(srcval) << gShift) & gDst) |
2513                            ((GetBValue(srcval) << bShift) & bDst);
2514                     *dstpixel++=dstval >> 16;
2515                 }
2516                 dstbits += linebytes;
2517             }
2518         }
2519         break;
2520     }
2521 }
2522
2523
2524 /***********************************************************************
2525  *           X11DRV_DIB_SetImageBits_24
2526  *
2527  * SetDIBits for a 24-bit deep DIB.
2528  */
2529 static void X11DRV_DIB_SetImageBits_24( int lines, const BYTE *srcbits,
2530                                  DWORD srcwidth, DWORD dstwidth, int left,
2531                                  X11DRV_PDEVICE *physDev,
2532                                  DWORD rSrc, DWORD gSrc, DWORD bSrc,
2533                                  XImage *bmpImage, DWORD linebytes )
2534 {
2535     DWORD x;
2536     int h, width = min(srcwidth, dstwidth);
2537     const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_dst_byteswap;
2538
2539     if (lines < 0 )
2540     {
2541         lines = -lines;
2542         srcbits = srcbits + linebytes * (lines - 1);
2543         linebytes = -linebytes;
2544     }
2545
2546     switch (bmpImage->depth)
2547     {
2548     case 24:
2549         if (bmpImage->bits_per_pixel==24) {
2550             char* dstbits;
2551
2552             srcbits=srcbits+left*3;
2553             dstbits=bmpImage->data+left*3+(lines-1)*bmpImage->bytes_per_line;
2554
2555             if (bmpImage->green_mask!=0x00ff00 ||
2556                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2557                 goto notsupported;
2558             } else if (rSrc==bmpImage->red_mask) {
2559                 /* ==== rgb 888 dib -> rgb 888 bmp ==== */
2560                 /* ==== bgr 888 dib -> bgr 888 bmp ==== */
2561                 convs->Convert_888_asis
2562                     (width,lines,
2563                      srcbits,linebytes,
2564                      dstbits,-bmpImage->bytes_per_line);
2565             } else {
2566                 /* ==== rgb 888 dib -> bgr 888 bmp ==== */
2567                 /* ==== bgr 888 dib -> rgb 888 bmp ==== */
2568                 convs->Convert_888_reverse
2569                     (width,lines,
2570                      srcbits,linebytes,
2571                      dstbits,-bmpImage->bytes_per_line);
2572             }
2573             break;
2574         }
2575         /* fall through */
2576
2577     case 32:
2578         {
2579             char* dstbits;
2580
2581             srcbits=srcbits+left*3;
2582             dstbits=bmpImage->data+left*4+(lines-1)*bmpImage->bytes_per_line;
2583
2584             if (bmpImage->green_mask!=0x00ff00 ||
2585                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2586                 goto notsupported;
2587             } else if (rSrc==bmpImage->red_mask) {
2588                 /* ==== rgb 888 dib -> rgb 0888 bmp ==== */
2589                 /* ==== bgr 888 dib -> bgr 0888 bmp ==== */
2590                 convs->Convert_888_to_0888_asis
2591                     (width,lines,
2592                      srcbits,linebytes,
2593                      dstbits,-bmpImage->bytes_per_line);
2594             } else {
2595                 /* ==== rgb 888 dib -> bgr 0888 bmp ==== */
2596                 /* ==== bgr 888 dib -> rgb 0888 bmp ==== */
2597                 convs->Convert_888_to_0888_reverse
2598                     (width,lines,
2599                      srcbits,linebytes,
2600                      dstbits,-bmpImage->bytes_per_line);
2601             }
2602             break;
2603         }
2604
2605     case 15:
2606     case 16:
2607         {
2608             char* dstbits;
2609
2610             srcbits=srcbits+left*3;
2611             dstbits=bmpImage->data+left*2+(lines-1)*bmpImage->bytes_per_line;
2612
2613             if (bmpImage->green_mask==0x03e0) {
2614                 if ((rSrc==0xff0000 && bmpImage->red_mask==0x7f00) ||
2615                     (bSrc==0xff0000 && bmpImage->blue_mask==0x7f00)) {
2616                     /* ==== rgb 888 dib -> rgb 555 bmp ==== */
2617                     /* ==== bgr 888 dib -> bgr 555 bmp ==== */
2618                     convs->Convert_888_to_555_asis
2619                         (width,lines,
2620                          srcbits,linebytes,
2621                          dstbits,-bmpImage->bytes_per_line);
2622                 } else if ((rSrc==0xff && bmpImage->red_mask==0x7f00) ||
2623                            (bSrc==0xff && bmpImage->blue_mask==0x7f00)) {
2624                     /* ==== rgb 888 dib -> bgr 555 bmp ==== */
2625                     /* ==== bgr 888 dib -> rgb 555 bmp ==== */
2626                     convs->Convert_888_to_555_reverse
2627                         (width,lines,
2628                          srcbits,linebytes,
2629                          dstbits,-bmpImage->bytes_per_line);
2630                 } else {
2631                     goto notsupported;
2632                 }
2633             } else if (bmpImage->green_mask==0x07e0) {
2634                 if ((rSrc==0xff0000 && bmpImage->red_mask==0xf800) ||
2635                     (bSrc==0xff0000 && bmpImage->blue_mask==0xf800)) {
2636                     /* ==== rgb 888 dib -> rgb 565 bmp ==== */
2637                     /* ==== bgr 888 dib -> bgr 565 bmp ==== */
2638                     convs->Convert_888_to_565_asis
2639                         (width,lines,
2640                          srcbits,linebytes,
2641                          dstbits,-bmpImage->bytes_per_line);
2642                 } else if ((rSrc==0xff && bmpImage->red_mask==0xf800) ||
2643                            (bSrc==0xff && bmpImage->blue_mask==0xf800)) {
2644                     /* ==== rgb 888 dib -> bgr 565 bmp ==== */
2645                     /* ==== bgr 888 dib -> rgb 565 bmp ==== */
2646                     convs->Convert_888_to_565_reverse
2647                         (width,lines,
2648                          srcbits,linebytes,
2649                          dstbits,-bmpImage->bytes_per_line);
2650                 } else {
2651                     goto notsupported;
2652                 }
2653             } else {
2654                 goto notsupported;
2655             }
2656         }
2657         break;
2658
2659     default:
2660     notsupported:
2661         WARN("from 24 bit DIB (%x,%x,%x) to unknown %d bit bitmap (%lx,%lx,%lx)\n",
2662               rSrc, gSrc, bSrc, bmpImage->bits_per_pixel, bmpImage->red_mask,
2663               bmpImage->green_mask, bmpImage->blue_mask );
2664         /* fall through */
2665     case 1:
2666     case 4:
2667     case 8:
2668         {
2669             /* ==== rgb 888 dib -> any bmp format ==== */
2670             const BYTE* srcbyte;
2671
2672             /* Windows only supports one 24bpp DIB format: RGB888 */
2673             srcbits+=left*3;
2674             for (h = lines - 1; h >= 0; h--) {
2675                 srcbyte = srcbits;
2676                 for (x = left; x < width+left; x++) {
2677                     XPutPixel(bmpImage, x, h,
2678                               X11DRV_PALETTE_ToPhysical
2679                               (physDev, RGB(srcbyte[2], srcbyte[1], srcbyte[0])));
2680                     srcbyte+=3;
2681                 }
2682                 srcbits += linebytes;
2683             }
2684         }
2685         break;
2686     }
2687 }
2688
2689
2690 /***********************************************************************
2691  *           X11DRV_DIB_GetImageBits_24
2692  *
2693  * GetDIBits for an 24-bit deep DIB.
2694  */
2695 static void X11DRV_DIB_GetImageBits_24( X11DRV_PDEVICE *physDev, int lines, BYTE *dstbits,
2696                                         DWORD dstwidth, DWORD srcwidth,
2697                                         PALETTEENTRY *srccolors,
2698                                         DWORD rDst, DWORD gDst, DWORD bDst,
2699                                         XImage *bmpImage, DWORD linebytes )
2700 {
2701     DWORD x;
2702     int h, width = min(srcwidth, dstwidth);
2703     const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_src_byteswap;
2704
2705     if (lines < 0 )
2706     {
2707         lines = -lines;
2708         dstbits = dstbits + ( linebytes * (lines-1) );
2709         linebytes = -linebytes;
2710     }
2711
2712     switch (bmpImage->depth)
2713     {
2714     case 24:
2715         if (bmpImage->bits_per_pixel==24) {
2716             const char* srcbits;
2717
2718             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2719
2720             if (bmpImage->green_mask!=0x00ff00 ||
2721                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2722                 goto notsupported;
2723             } else if (rDst==bmpImage->red_mask) {
2724                 /* ==== rgb 888 bmp -> rgb 888 dib ==== */
2725                 /* ==== bgr 888 bmp -> bgr 888 dib ==== */
2726                 convs->Convert_888_asis
2727                     (width,lines,
2728                      srcbits,-bmpImage->bytes_per_line,
2729                      dstbits,linebytes);
2730             } else {
2731                 /* ==== rgb 888 bmp -> bgr 888 dib ==== */
2732                 /* ==== bgr 888 bmp -> rgb 888 dib ==== */
2733                 convs->Convert_888_reverse
2734                     (width,lines,
2735                      srcbits,-bmpImage->bytes_per_line,
2736                      dstbits,linebytes);
2737             }
2738             break;
2739         }
2740         /* fall through */
2741
2742     case 32:
2743         {
2744             const char* srcbits;
2745
2746             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2747
2748             if (bmpImage->green_mask!=0x00ff00 ||
2749                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2750                 goto notsupported;
2751             } else if (rDst==bmpImage->red_mask) {
2752                 /* ==== rgb 888 bmp -> rgb 0888 dib ==== */
2753                 /* ==== bgr 888 bmp -> bgr 0888 dib ==== */
2754                 convs->Convert_0888_to_888_asis
2755                     (width,lines,
2756                      srcbits,-bmpImage->bytes_per_line,
2757                      dstbits,linebytes);
2758             } else {
2759                 /* ==== rgb 888 bmp -> bgr 0888 dib ==== */
2760                 /* ==== bgr 888 bmp -> rgb 0888 dib ==== */
2761                 convs->Convert_0888_to_888_reverse
2762                     (width,lines,
2763                      srcbits,-bmpImage->bytes_per_line,
2764                      dstbits,linebytes);
2765             }
2766             break;
2767         }
2768
2769     case 15:
2770     case 16:
2771         {
2772             const char* srcbits;
2773
2774             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2775
2776             if (bmpImage->green_mask==0x03e0) {
2777                 if ((rDst==0xff0000 && bmpImage->red_mask==0x7f00) ||
2778                     (bDst==0xff0000 && bmpImage->blue_mask==0x7f00)) {
2779                     /* ==== rgb 555 bmp -> rgb 888 dib ==== */
2780                     /* ==== bgr 555 bmp -> bgr 888 dib ==== */
2781                     convs->Convert_555_to_888_asis
2782                         (width,lines,
2783                          srcbits,-bmpImage->bytes_per_line,
2784                          dstbits,linebytes);
2785                 } else if ((rDst==0xff && bmpImage->red_mask==0x7f00) ||
2786                            (bDst==0xff && bmpImage->blue_mask==0x7f00)) {
2787                     /* ==== rgb 555 bmp -> bgr 888 dib ==== */
2788                     /* ==== bgr 555 bmp -> rgb 888 dib ==== */
2789                     convs->Convert_555_to_888_reverse
2790                         (width,lines,
2791                          srcbits,-bmpImage->bytes_per_line,
2792                          dstbits,linebytes);
2793                 } else {
2794                     goto notsupported;
2795                 }
2796             } else if (bmpImage->green_mask==0x07e0) {
2797                 if ((rDst==0xff0000 && bmpImage->red_mask==0xf800) ||
2798                     (bDst==0xff0000 && bmpImage->blue_mask==0xf800)) {
2799                     /* ==== rgb 565 bmp -> rgb 888 dib ==== */
2800                     /* ==== bgr 565 bmp -> bgr 888 dib ==== */
2801                     convs->Convert_565_to_888_asis
2802                         (width,lines,
2803                          srcbits,-bmpImage->bytes_per_line,
2804                          dstbits,linebytes);
2805                 } else if ((rDst==0xff && bmpImage->red_mask==0xf800) ||
2806                            (bDst==0xff && bmpImage->blue_mask==0xf800)) {
2807                     /* ==== rgb 565 bmp -> bgr 888 dib ==== */
2808                     /* ==== bgr 565 bmp -> rgb 888 dib ==== */
2809                     convs->Convert_565_to_888_reverse
2810                         (width,lines,
2811                          srcbits,-bmpImage->bytes_per_line,
2812                          dstbits,linebytes);
2813                 } else {
2814                     goto notsupported;
2815                 }
2816             } else {
2817                 goto notsupported;
2818             }
2819         }
2820         break;
2821
2822     case 1:
2823     case 4:
2824         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
2825             && srccolors) {
2826             /* ==== pal 1 or 4 bmp -> rgb 888 dib ==== */
2827             BYTE* dstbyte;
2828
2829             /* Windows only supports one 24bpp DIB format: rgb 888 */
2830             for (h = lines - 1; h >= 0; h--) {
2831                 dstbyte=dstbits;
2832                 for (x = 0; x < width; x++) {
2833                     PALETTEENTRY srcval;
2834                     srcval=srccolors[XGetPixel(bmpImage, x, h)];
2835                     dstbyte[0]=srcval.peBlue;
2836                     dstbyte[1]=srcval.peGreen;
2837                     dstbyte[2]=srcval.peRed;
2838                     dstbyte+=3;
2839                 }
2840                 dstbits += linebytes;
2841             }
2842         } else {
2843             goto notsupported;
2844         }
2845         break;
2846
2847     case 8:
2848         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
2849             && srccolors) {
2850             /* ==== pal 8 bmp -> rgb 888 dib ==== */
2851             const void* srcbits;
2852             const BYTE* srcpixel;
2853             BYTE* dstbyte;
2854
2855             /* Windows only supports one 24bpp DIB format: rgb 888 */
2856             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2857             for (h = lines - 1; h >= 0; h--) {
2858                 srcpixel=srcbits;
2859                 dstbyte=dstbits;
2860                 for (x = 0; x < width; x++ ) {
2861                     PALETTEENTRY srcval;
2862                     srcval=srccolors[*srcpixel++];
2863                     dstbyte[0]=srcval.peBlue;
2864                     dstbyte[1]=srcval.peGreen;
2865                     dstbyte[2]=srcval.peRed;
2866                     dstbyte+=3;
2867                 }
2868                 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
2869                 dstbits += linebytes;
2870             }
2871         } else {
2872             goto notsupported;
2873         }
2874         break;
2875
2876     default:
2877     notsupported:
2878         {
2879             /* ==== any bmp format -> 888 dib ==== */
2880             BYTE* dstbyte;
2881
2882             WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 24 bit DIB (%x,%x,%x)\n",
2883                   bmpImage->depth, bmpImage->red_mask,
2884                   bmpImage->green_mask, bmpImage->blue_mask,
2885                   rDst, gDst, bDst );
2886
2887             /* Windows only supports one 24bpp DIB format: rgb 888 */
2888             for (h = lines - 1; h >= 0; h--) {
2889                 dstbyte=dstbits;
2890                 for (x = 0; x < width; x++) {
2891                     COLORREF srcval=X11DRV_PALETTE_ToLogical
2892                         (physDev, XGetPixel( bmpImage, x, h ));
2893                     dstbyte[0]=GetBValue(srcval);
2894                     dstbyte[1]=GetGValue(srcval);
2895                     dstbyte[2]=GetRValue(srcval);
2896                     dstbyte+=3;
2897                 }
2898                 dstbits += linebytes;
2899             }
2900         }
2901         break;
2902     }
2903 }
2904
2905
2906 /***********************************************************************
2907  *           X11DRV_DIB_SetImageBits_32
2908  *
2909  * SetDIBits for a 32-bit deep DIB.
2910  */
2911 static void X11DRV_DIB_SetImageBits_32(int lines, const BYTE *srcbits,
2912                                        DWORD srcwidth, DWORD dstwidth, int left,
2913                                        X11DRV_PDEVICE *physDev,
2914                                        DWORD rSrc, DWORD gSrc, DWORD bSrc,
2915                                        XImage *bmpImage,
2916                                        DWORD linebytes)
2917 {
2918     DWORD x;
2919     int h, width = min(srcwidth, dstwidth);
2920     const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_dst_byteswap;
2921
2922     if (lines < 0 )
2923     {
2924        lines = -lines;
2925        srcbits = srcbits + ( linebytes * (lines-1) );
2926        linebytes = -linebytes;
2927     }
2928
2929     switch (bmpImage->depth)
2930     {
2931     case 24:
2932         if (bmpImage->bits_per_pixel==24) {
2933             char* dstbits;
2934
2935             srcbits=srcbits+left*4;
2936             dstbits=bmpImage->data+left*3+(lines-1)*bmpImage->bytes_per_line;
2937
2938             if (rSrc==bmpImage->red_mask && gSrc==bmpImage->green_mask && bSrc==bmpImage->blue_mask) {
2939                 /* ==== rgb 0888 dib -> rgb 888 bmp ==== */
2940                 /* ==== bgr 0888 dib -> bgr 888 bmp ==== */
2941                 convs->Convert_0888_to_888_asis
2942                     (width,lines,
2943                      srcbits,linebytes,
2944                      dstbits,-bmpImage->bytes_per_line);
2945             } else if (bmpImage->green_mask!=0x00ff00 ||
2946                        (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2947                 goto notsupported;
2948                 /* the tests below assume sane bmpImage masks */
2949             } else if (rSrc==bmpImage->blue_mask && gSrc==bmpImage->green_mask && bSrc==bmpImage->red_mask) {
2950                 /* ==== rgb 0888 dib -> bgr 888 bmp ==== */
2951                 /* ==== bgr 0888 dib -> rgb 888 bmp ==== */
2952                 convs->Convert_0888_to_888_reverse
2953                     (width,lines,
2954                      srcbits,linebytes,
2955                      dstbits,-bmpImage->bytes_per_line);
2956             } else if (bmpImage->blue_mask==0xff) {
2957                 /* ==== any 0888 dib -> rgb 888 bmp ==== */
2958                 convs->Convert_any0888_to_rgb888
2959                     (width,lines,
2960                      srcbits,linebytes,
2961                      rSrc,gSrc,bSrc,
2962                      dstbits,-bmpImage->bytes_per_line);
2963             } else {
2964                 /* ==== any 0888 dib -> bgr 888 bmp ==== */
2965                 convs->Convert_any0888_to_bgr888
2966                     (width,lines,
2967                      srcbits,linebytes,
2968                      rSrc,gSrc,bSrc,
2969                      dstbits,-bmpImage->bytes_per_line);
2970             }
2971             break;
2972         }
2973         /* fall through */
2974
2975     case 32:
2976         {
2977             char* dstbits;
2978
2979             srcbits=srcbits+left*4;
2980             dstbits=bmpImage->data+left*4+(lines-1)*bmpImage->bytes_per_line;
2981
2982             if (gSrc==bmpImage->green_mask) {
2983                 if (rSrc==bmpImage->red_mask && bSrc==bmpImage->blue_mask) {
2984                     /* ==== rgb 0888 dib -> rgb 0888 bmp ==== */
2985                     /* ==== bgr 0888 dib -> bgr 0888 bmp ==== */
2986                     convs->Convert_0888_asis
2987                         (width,lines,
2988                          srcbits,linebytes,
2989                          dstbits,-bmpImage->bytes_per_line);
2990                 } else if (bmpImage->green_mask!=0x00ff00 ||
2991                            (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2992                     goto notsupported;
2993                     /* the tests below assume sane bmpImage masks */
2994                 } else if (rSrc==bmpImage->blue_mask && bSrc==bmpImage->red_mask) {
2995                     /* ==== rgb 0888 dib -> bgr 0888 bmp ==== */
2996                     /* ==== bgr 0888 dib -> rgb 0888 bmp ==== */
2997                     convs->Convert_0888_reverse
2998                         (width,lines,
2999                          srcbits,linebytes,
3000                          dstbits,-bmpImage->bytes_per_line);
3001                 } else {
3002                     /* ==== any 0888 dib -> any 0888 bmp ==== */
3003                     convs->Convert_0888_any
3004                         (width,lines,
3005                          srcbits,linebytes,
3006                          rSrc,gSrc,bSrc,
3007                          dstbits,-bmpImage->bytes_per_line,
3008                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
3009                 }
3010             } else if (bmpImage->green_mask!=0x00ff00 ||
3011                        (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
3012                 goto notsupported;
3013                 /* the tests below assume sane bmpImage masks */
3014             } else {
3015                 /* ==== any 0888 dib -> any 0888 bmp ==== */
3016                 convs->Convert_0888_any
3017                     (width,lines,
3018                      srcbits,linebytes,
3019                      rSrc,gSrc,bSrc,
3020                      dstbits,-bmpImage->bytes_per_line,
3021                      bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
3022             }
3023         }
3024         break;
3025
3026     case 15:
3027     case 16:
3028         {
3029             char* dstbits;
3030
3031             srcbits=srcbits+left*4;
3032             dstbits=bmpImage->data+left*2+(lines-1)*bmpImage->bytes_per_line;
3033
3034             if (rSrc==0xff0000 && gSrc==0x00ff00 && bSrc==0x0000ff) {
3035                 if (bmpImage->green_mask==0x03e0) {
3036                     if (bmpImage->red_mask==0x7f00) {
3037                         /* ==== rgb 0888 dib -> rgb 555 bmp ==== */
3038                         convs->Convert_0888_to_555_asis
3039                             (width,lines,
3040                              srcbits,linebytes,
3041                              dstbits,-bmpImage->bytes_per_line);
3042                     } else if (bmpImage->blue_mask==0x7f00) {
3043                         /* ==== rgb 0888 dib -> bgr 555 bmp ==== */
3044                         convs->Convert_0888_to_555_reverse
3045                             (width,lines,
3046                              srcbits,linebytes,
3047                              dstbits,-bmpImage->bytes_per_line);
3048                     } else {
3049                         goto notsupported;
3050                     }
3051                 } else if (bmpImage->green_mask==0x07e0) {
3052                     if (bmpImage->red_mask==0xf800) {
3053                         /* ==== rgb 0888 dib -> rgb 565 bmp ==== */
3054                         convs->Convert_0888_to_565_asis
3055                             (width,lines,
3056                              srcbits,linebytes,
3057                              dstbits,-bmpImage->bytes_per_line);
3058                     } else if (bmpImage->blue_mask==0xf800) {
3059                         /* ==== rgb 0888 dib -> bgr 565 bmp ==== */
3060                         convs->Convert_0888_to_565_reverse
3061                             (width,lines,
3062                              srcbits,linebytes,
3063                              dstbits,-bmpImage->bytes_per_line);
3064                     } else {
3065                         goto notsupported;
3066                     }
3067                 } else {
3068                     goto notsupported;
3069                 }
3070             } else if (rSrc==0x0000ff && gSrc==0x00ff00 && bSrc==0xff0000) {
3071                 if (bmpImage->green_mask==0x03e0) {
3072                     if (bmpImage->blue_mask==0x7f00) {
3073                         /* ==== bgr 0888 dib -> bgr 555 bmp ==== */
3074                         convs->Convert_0888_to_555_asis
3075                             (width,lines,
3076                              srcbits,linebytes,
3077                              dstbits,-bmpImage->bytes_per_line);
3078                     } else if (bmpImage->red_mask==0x7f00) {
3079                         /* ==== bgr 0888 dib -> rgb 555 bmp ==== */
3080                         convs->Convert_0888_to_555_reverse
3081                             (width,lines,
3082                              srcbits,linebytes,
3083                              dstbits,-bmpImage->bytes_per_line);
3084                     } else {
3085                         goto notsupported;
3086                     }
3087                 } else if (bmpImage->green_mask==0x07e0) {
3088                     if (bmpImage->blue_mask==0xf800) {
3089                         /* ==== bgr 0888 dib -> bgr 565 bmp ==== */
3090                         convs->Convert_0888_to_565_asis
3091                             (width,lines,
3092                              srcbits,linebytes,
3093                              dstbits,-bmpImage->bytes_per_line);
3094                     } else if (bmpImage->red_mask==0xf800) {
3095                         /* ==== bgr 0888 dib -> rgb 565 bmp ==== */
3096                         convs->Convert_0888_to_565_reverse
3097                             (width,lines,
3098                              srcbits,linebytes,
3099                              dstbits,-bmpImage->bytes_per_line);
3100                     } else {
3101                         goto notsupported;
3102                     }
3103                 } else {
3104                     goto notsupported;
3105                 }
3106             } else {
3107                 if (bmpImage->green_mask==0x03e0 &&
3108                     (bmpImage->red_mask==0x7f00 ||
3109                      bmpImage->blue_mask==0x7f00)) {
3110                     /* ==== any 0888 dib -> rgb or bgr 555 bmp ==== */
3111                     convs->Convert_any0888_to_5x5
3112                         (width,lines,
3113                          srcbits,linebytes,
3114                          rSrc,gSrc,bSrc,
3115                          dstbits,-bmpImage->bytes_per_line,
3116                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
3117                 } else if (bmpImage->green_mask==0x07e0 &&
3118                            (bmpImage->red_mask==0xf800 ||
3119                             bmpImage->blue_mask==0xf800)) {
3120                     /* ==== any 0888 dib -> rgb or bgr 565 bmp ==== */
3121                     convs->Convert_any0888_to_5x5
3122                         (width,lines,
3123                          srcbits,linebytes,
3124                          rSrc,gSrc,bSrc,
3125                          dstbits,-bmpImage->bytes_per_line,
3126                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
3127                 } else {
3128                     goto notsupported;
3129                 }
3130             }
3131         }
3132         break;
3133
3134     default:
3135     notsupported:
3136         WARN("from 32 bit DIB (%x,%x,%x) to unknown %d bit bitmap (%lx,%lx,%lx)\n",
3137               rSrc, gSrc, bSrc, bmpImage->bits_per_pixel, bmpImage->red_mask,
3138               bmpImage->green_mask, bmpImage->blue_mask );
3139         /* fall through */
3140     case 1:
3141     case 4:
3142     case 8:
3143         {
3144             /* ==== any 0888 dib -> pal 1, 4 or 8 bmp ==== */
3145             const DWORD* srcpixel;
3146             int rShift,gShift,bShift;
3147
3148             rShift=X11DRV_DIB_MaskToShift(rSrc);
3149             gShift=X11DRV_DIB_MaskToShift(gSrc);
3150             bShift=X11DRV_DIB_MaskToShift(bSrc);
3151             srcbits+=left*4;
3152             for (h = lines - 1; h >= 0; h--) {
3153                 srcpixel=(const DWORD*)srcbits;
3154                 for (x = left; x < width+left; x++) {
3155                     DWORD srcvalue;
3156                     BYTE red,green,blue;
3157                     srcvalue=*srcpixel++;
3158                     red=  (srcvalue >> rShift) & 0xff;
3159                     green=(srcvalue >> gShift) & 0xff;
3160                     blue= (srcvalue >> bShift) & 0xff;
3161                     XPutPixel(bmpImage, x, h, X11DRV_PALETTE_ToPhysical
3162                               (physDev, RGB(red,green,blue)));
3163                 }
3164                 srcbits += linebytes;
3165             }
3166         }
3167         break;
3168     }
3169
3170 }
3171
3172 /***********************************************************************
3173  *           X11DRV_DIB_GetImageBits_32
3174  *
3175  * GetDIBits for an 32-bit deep DIB.
3176  */
3177 static void X11DRV_DIB_GetImageBits_32( X11DRV_PDEVICE *physDev, int lines, BYTE *dstbits,
3178                                         DWORD dstwidth, DWORD srcwidth,
3179                                         PALETTEENTRY *srccolors,
3180                                         DWORD rDst, DWORD gDst, DWORD bDst,
3181                                         XImage *bmpImage, int linebytes )
3182 {
3183     DWORD x;
3184     int h, width = min(srcwidth, dstwidth);
3185     const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_src_byteswap;
3186
3187     if (lines < 0 )
3188     {
3189         lines = -lines;
3190         dstbits = dstbits + ( linebytes * (lines-1) );
3191         linebytes = -linebytes;
3192     }
3193
3194     switch (bmpImage->depth)
3195     {
3196     case 24:
3197         if (bmpImage->bits_per_pixel==24) {
3198             const void* srcbits;
3199
3200             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3201
3202             if (rDst==bmpImage->red_mask && gDst==bmpImage->green_mask && bDst==bmpImage->blue_mask) {
3203                 /* ==== rgb 888 bmp -> rgb 0888 dib ==== */
3204                 /* ==== bgr 888 bmp -> bgr 0888 dib ==== */
3205                 convs->Convert_888_to_0888_asis
3206                     (width,lines,
3207                      srcbits,-bmpImage->bytes_per_line,
3208                      dstbits,linebytes);
3209             } else if (bmpImage->green_mask!=0x00ff00 ||
3210                        (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
3211                 goto notsupported;
3212                 /* the tests below assume sane bmpImage masks */
3213             } else if (rDst==bmpImage->blue_mask && gDst==bmpImage->green_mask && bDst==bmpImage->red_mask) {
3214                 /* ==== rgb 888 bmp -> bgr 0888 dib ==== */
3215                 /* ==== bgr 888 bmp -> rgb 0888 dib ==== */
3216                 convs->Convert_888_to_0888_reverse
3217                     (width,lines,
3218                      srcbits,-bmpImage->bytes_per_line,
3219                      dstbits,linebytes);
3220             } else if (bmpImage->blue_mask==0xff) {
3221                 /* ==== rgb 888 bmp -> any 0888 dib ==== */
3222                 convs->Convert_rgb888_to_any0888
3223                     (width,lines,
3224                      srcbits,-bmpImage->bytes_per_line,
3225                      dstbits,linebytes,
3226                      rDst,gDst,bDst);
3227             } else {
3228                 /* ==== bgr 888 bmp -> any 0888 dib ==== */
3229                 convs->Convert_bgr888_to_any0888
3230                     (width,lines,
3231                      srcbits,-bmpImage->bytes_per_line,
3232                      dstbits,linebytes,
3233                      rDst,gDst,bDst);
3234             }
3235             break;
3236         }
3237         /* fall through */
3238
3239     case 32:
3240         {
3241             const char* srcbits;
3242
3243             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3244
3245             if (gDst==bmpImage->green_mask) {
3246                 if (rDst==bmpImage->red_mask && bDst==bmpImage->blue_mask) {
3247                     /* ==== rgb 0888 bmp -> rgb 0888 dib ==== */
3248                     /* ==== bgr 0888 bmp -> bgr 0888 dib ==== */
3249                     convs->Convert_0888_asis
3250                         (width,lines,
3251                          srcbits,-bmpImage->bytes_per_line,
3252                          dstbits,linebytes);
3253                 } else if (bmpImage->green_mask!=0x00ff00 ||
3254                            (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
3255                     goto notsupported;
3256                     /* the tests below assume sane bmpImage masks */
3257                 } else if (rDst==bmpImage->blue_mask && bDst==bmpImage->red_mask) {
3258                     /* ==== rgb 0888 bmp -> bgr 0888 dib ==== */
3259                     /* ==== bgr 0888 bmp -> rgb 0888 dib ==== */
3260                     convs->Convert_0888_reverse
3261                         (width,lines,
3262                          srcbits,-bmpImage->bytes_per_line,
3263                          dstbits,linebytes);
3264                 } else {
3265                     /* ==== any 0888 bmp -> any 0888 dib ==== */
3266                     convs->Convert_0888_any
3267                         (width,lines,
3268                          srcbits,-bmpImage->bytes_per_line,
3269                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask,
3270                          dstbits,linebytes,
3271                          rDst,gDst,bDst);
3272                 }
3273             } else if (bmpImage->green_mask!=0x00ff00 ||
3274                        (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
3275                 goto notsupported;
3276                 /* the tests below assume sane bmpImage masks */
3277             } else {
3278                 /* ==== any 0888 bmp -> any 0888 dib ==== */
3279                 convs->Convert_0888_any
3280                     (width,lines,
3281                      srcbits,-bmpImage->bytes_per_line,
3282                      bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask,
3283                      dstbits,linebytes,
3284                      rDst,gDst,bDst);
3285             }
3286         }
3287         break;
3288
3289     case 15:
3290     case 16:
3291         {
3292             const char* srcbits;
3293
3294             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3295
3296             if (rDst==0xff0000 && gDst==0x00ff00 && bDst==0x0000ff) {
3297                 if (bmpImage->green_mask==0x03e0) {
3298                     if (bmpImage->red_mask==0x7f00) {
3299                         /* ==== rgb 555 bmp -> rgb 0888 dib ==== */
3300                         convs->Convert_555_to_0888_asis
3301                             (width,lines,
3302                              srcbits,-bmpImage->bytes_per_line,
3303                              dstbits,linebytes);
3304                     } else if (bmpImage->blue_mask==0x7f00) {
3305                         /* ==== bgr 555 bmp -> rgb 0888 dib ==== */
3306                         convs->Convert_555_to_0888_reverse
3307                             (width,lines,
3308                              srcbits,-bmpImage->bytes_per_line,
3309                              dstbits,linebytes);
3310                     } else {
3311                         goto notsupported;
3312                     }
3313                 } else if (bmpImage->green_mask==0x07e0) {
3314                     if (bmpImage->red_mask==0xf800) {
3315                         /* ==== rgb 565 bmp -> rgb 0888 dib ==== */
3316                         convs->Convert_565_to_0888_asis
3317                             (width,lines,
3318                              srcbits,-bmpImage->bytes_per_line,
3319                              dstbits,linebytes);
3320                     } else if (bmpImage->blue_mask==0xf800) {
3321                         /* ==== bgr 565 bmp -> rgb 0888 dib ==== */
3322                         convs->Convert_565_to_0888_reverse
3323                             (width,lines,
3324                              srcbits,-bmpImage->bytes_per_line,
3325                              dstbits,linebytes);
3326                     } else {
3327                         goto notsupported;
3328                     }
3329                 } else {
3330                     goto notsupported;
3331                 }
3332             } else if (rDst==0x0000ff && gDst==0x00ff00 && bDst==0xff0000) {
3333                 if (bmpImage->green_mask==0x03e0) {
3334                     if (bmpImage->blue_mask==0x7f00) {
3335                         /* ==== bgr 555 bmp -> bgr 0888 dib ==== */
3336                         convs->Convert_555_to_0888_asis
3337                             (width,lines,
3338                              srcbits,-bmpImage->bytes_per_line,
3339                              dstbits,linebytes);
3340                     } else if (bmpImage->red_mask==0x7f00) {
3341                         /* ==== rgb 555 bmp -> bgr 0888 dib ==== */
3342                         convs->Convert_555_to_0888_reverse
3343                             (width,lines,
3344                              srcbits,-bmpImage->bytes_per_line,
3345                              dstbits,linebytes);
3346                     } else {
3347                         goto notsupported;
3348                     }
3349                 } else if (bmpImage->green_mask==0x07e0) {
3350                     if (bmpImage->blue_mask==0xf800) {
3351                         /* ==== bgr 565 bmp -> bgr 0888 dib ==== */
3352                         convs->Convert_565_to_0888_asis
3353                             (width,lines,
3354                              srcbits,-bmpImage->bytes_per_line,
3355                              dstbits,linebytes);
3356                     } else if (bmpImage->red_mask==0xf800) {
3357                         /* ==== rgb 565 bmp -> bgr 0888 dib ==== */
3358                         convs->Convert_565_to_0888_reverse
3359                             (width,lines,
3360                              srcbits,-bmpImage->bytes_per_line,
3361                              dstbits,linebytes);
3362                     } else {
3363                         goto notsupported;
3364                     }
3365                 } else {
3366                     goto notsupported;
3367                 }
3368             } else {
3369                 if (bmpImage->green_mask==0x03e0 &&
3370                     (bmpImage->red_mask==0x7f00 ||
3371                      bmpImage->blue_mask==0x7f00)) {
3372                     /* ==== rgb or bgr 555 bmp -> any 0888 dib ==== */
3373                     convs->Convert_5x5_to_any0888
3374                         (width,lines,
3375                          srcbits,-bmpImage->bytes_per_line,
3376                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask,
3377                          dstbits,linebytes,
3378                          rDst,gDst,bDst);
3379                 } else if (bmpImage->green_mask==0x07e0 &&
3380                            (bmpImage->red_mask==0xf800 ||
3381                             bmpImage->blue_mask==0xf800)) {
3382                     /* ==== rgb or bgr 565 bmp -> any 0888 dib ==== */
3383                     convs->Convert_5x5_to_any0888
3384                         (width,lines,
3385                          srcbits,-bmpImage->bytes_per_line,
3386                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask,
3387                          dstbits,linebytes,
3388                          rDst,gDst,bDst);
3389                 } else {
3390                     goto notsupported;
3391                 }
3392             }
3393         }
3394         break;
3395
3396     case 1:
3397     case 4:
3398         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
3399             && srccolors) {
3400             /* ==== pal 1 or 4 bmp -> any 0888 dib ==== */
3401             int rShift,gShift,bShift;
3402             DWORD* dstpixel;
3403
3404             rShift=X11DRV_DIB_MaskToShift(rDst);
3405             gShift=X11DRV_DIB_MaskToShift(gDst);
3406             bShift=X11DRV_DIB_MaskToShift(bDst);
3407             for (h = lines - 1; h >= 0; h--) {
3408                 dstpixel=(DWORD*)dstbits;
3409                 for (x = 0; x < width; x++) {
3410                     PALETTEENTRY srcval;
3411                     srcval = srccolors[XGetPixel(bmpImage, x, h)];
3412                     *dstpixel++=(srcval.peRed   << rShift) |
3413                                 (srcval.peGreen << gShift) |
3414                                 (srcval.peBlue  << bShift);
3415                 }
3416                 dstbits += linebytes;
3417             }
3418         } else {
3419             goto notsupported;
3420         }
3421         break;
3422
3423     case 8:
3424         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
3425             && srccolors) {
3426             /* ==== pal 8 bmp -> any 0888 dib ==== */
3427             int rShift,gShift,bShift;
3428             const void* srcbits;
3429             const BYTE* srcpixel;
3430             DWORD* dstpixel;
3431
3432             rShift=X11DRV_DIB_MaskToShift(rDst);
3433             gShift=X11DRV_DIB_MaskToShift(gDst);
3434             bShift=X11DRV_DIB_MaskToShift(bDst);
3435             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3436             for (h = lines - 1; h >= 0; h--) {
3437                 srcpixel=srcbits;
3438                 dstpixel=(DWORD*)dstbits;
3439                 for (x = 0; x < width; x++) {
3440                     PALETTEENTRY srcval;
3441                     srcval=srccolors[*srcpixel++];
3442                     *dstpixel++=(srcval.peRed   << rShift) |
3443                                 (srcval.peGreen << gShift) |
3444                                 (srcval.peBlue  << bShift);
3445                 }
3446                 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
3447                 dstbits += linebytes;
3448             }
3449         } else {
3450             goto notsupported;
3451         }
3452         break;
3453
3454     default:
3455     notsupported:
3456         {
3457             /* ==== any bmp format -> any 0888 dib ==== */
3458             int rShift,gShift,bShift;
3459             DWORD* dstpixel;
3460
3461             WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 32 bit DIB (%x,%x,%x)\n",
3462                   bmpImage->depth, bmpImage->red_mask,
3463                   bmpImage->green_mask, bmpImage->blue_mask,
3464                   rDst,gDst,bDst);
3465
3466             rShift=X11DRV_DIB_MaskToShift(rDst);
3467             gShift=X11DRV_DIB_MaskToShift(gDst);
3468             bShift=X11DRV_DIB_MaskToShift(bDst);
3469             for (h = lines - 1; h >= 0; h--) {
3470                 dstpixel=(DWORD*)dstbits;
3471                 for (x = 0; x < width; x++) {
3472                     COLORREF srcval;
3473                     srcval=X11DRV_PALETTE_ToLogical(physDev, XGetPixel(bmpImage, x, h));
3474                     *dstpixel++=(GetRValue(srcval) << rShift) |
3475                                 (GetGValue(srcval) << gShift) |
3476                                 (GetBValue(srcval) << bShift);
3477                 }
3478                 dstbits += linebytes;
3479             }
3480         }
3481         break;
3482     }
3483 }
3484
3485 static int XGetSubImageErrorHandler(Display *dpy, XErrorEvent *event, void *arg)
3486 {
3487     return (event->request_code == X_GetImage && event->error_code == BadMatch);
3488 }
3489
3490 /***********************************************************************
3491  *           X11DRV_DIB_SetImageBits_GetSubImage
3492  *
3493  *  Helper for X11DRV_DIB_SetImageBits
3494  */
3495 static void X11DRV_DIB_SetImageBits_GetSubImage(
3496         const X11DRV_DIB_IMAGEBITS_DESCR *descr, XImage *bmpImage)
3497 {
3498     /* compressed bitmaps may contain gaps in them. So make a copy
3499      * of the existing pixels first */
3500     RECT bmprc, rc;
3501
3502     SetRect( &bmprc, descr->xDest, descr->yDest,
3503              descr->xDest + descr->width , descr->yDest + descr->height );
3504     GetRgnBox( descr->physDev->region, &rc );
3505     /* convert from dc to drawable origin */
3506     OffsetRect( &rc, descr->physDev->dc_rect.left, descr->physDev->dc_rect.top);
3507     /* clip visible rect with bitmap */
3508     if( IntersectRect( &rc, &rc, &bmprc))
3509     {
3510         X11DRV_expect_error( gdi_display, XGetSubImageErrorHandler, NULL );
3511         XGetSubImage( gdi_display, descr->drawable, rc.left, rc.top,
3512                       rc.right - rc.left, rc.bottom - rc.top, AllPlanes,
3513                       ZPixmap, bmpImage,
3514                       descr->xSrc + rc.left - bmprc.left,
3515                       descr->ySrc + rc.top - bmprc.top);
3516         X11DRV_check_error();
3517     }
3518 }
3519
3520 /***********************************************************************
3521  *           X11DRV_DIB_SetImageBits
3522  *
3523  * Transfer the bits to an X image.
3524  * Helper function for SetDIBits() and SetDIBitsToDevice().
3525  */
3526 static int X11DRV_DIB_SetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
3527 {
3528     int lines = descr->lines >= 0 ? descr->lines : -descr->lines;
3529     void *old_data = NULL;
3530     XImage *bmpImage;
3531
3532     wine_tsx11_lock();
3533     if (descr->image)
3534         bmpImage = descr->image;
3535     else {
3536         bmpImage = XCreateImage( gdi_display, visual, descr->depth, ZPixmap, 0, NULL,
3537                                  descr->infoWidth, lines, 32, 0 );
3538         bmpImage->data = HeapAlloc( GetProcessHeap(), 0, lines * bmpImage->bytes_per_line );
3539         if(bmpImage->data == NULL) {
3540             ERR("Out of memory!\n");
3541             XDestroyImage( bmpImage );
3542             wine_tsx11_unlock();
3543             return 0;
3544         }
3545         if (descr->shifts)
3546         {
3547             bmpImage->red_mask = descr->shifts->physicalRed.max << descr->shifts->physicalRed.shift;
3548             bmpImage->green_mask = descr->shifts->physicalGreen.max << descr->shifts->physicalGreen.shift;
3549             bmpImage->blue_mask = descr->shifts->physicalBlue.max << descr->shifts->physicalBlue.shift;
3550         }
3551     }
3552     wine_tsx11_unlock();
3553
3554     TRACE("Dib: depth=%d r=%x g=%x b=%x\n",
3555           descr->infoBpp,descr->rMask,descr->gMask,descr->bMask);
3556     TRACE("Bmp: depth=%d/%d r=%lx g=%lx b=%lx\n",
3557           bmpImage->depth,bmpImage->bits_per_pixel,
3558           bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
3559
3560 #ifdef HAVE_LIBXXSHM
3561     if (descr->shm_mode == X11DRV_SHM_PIXMAP
3562             && descr->xSrc == 0 && descr->ySrc == 0
3563             && descr->xDest == 0 && descr->yDest == 0)
3564     {
3565         TRACE("Using the shared pixmap data.\n");
3566
3567         wine_tsx11_lock();
3568         XSync( gdi_display, False );
3569         wine_tsx11_unlock();
3570
3571         old_data = descr->image->data;
3572         descr->image->data = descr->physBitmap->shminfo.shmaddr;
3573     }
3574 #endif
3575
3576       /* Transfer the pixels */
3577     __TRY
3578     {
3579         switch(descr->infoBpp)
3580         {
3581         case 1:
3582             X11DRV_DIB_SetImageBits_1( descr->lines, descr->bits, descr->infoWidth,
3583                                        descr->width, descr->xSrc, (int *)(descr->colorMap),
3584                                        bmpImage, descr->dibpitch );
3585             break;
3586         case 4:
3587             if (descr->compression) {
3588                 X11DRV_DIB_SetImageBits_GetSubImage( descr, bmpImage);
3589                 X11DRV_DIB_SetImageBits_RLE4( descr->lines, descr->bits,
3590                                               descr->infoWidth, descr->width,
3591                                               descr->xSrc, (int *)(descr->colorMap),
3592                                               bmpImage );
3593             } else
3594                 X11DRV_DIB_SetImageBits_4( descr->lines, descr->bits,
3595                                            descr->infoWidth, descr->width,
3596                                            descr->xSrc, (int*)(descr->colorMap),
3597                                            bmpImage, descr->dibpitch );
3598             break;
3599         case 8:
3600             if (descr->compression) {
3601                 X11DRV_DIB_SetImageBits_GetSubImage( descr, bmpImage);
3602                 X11DRV_DIB_SetImageBits_RLE8( descr->lines, descr->bits,
3603                                               descr->infoWidth, descr->width,
3604                                               descr->xSrc, (int *)(descr->colorMap),
3605                                               bmpImage );
3606             } else
3607                 X11DRV_DIB_SetImageBits_8( descr->lines, descr->bits,
3608                                            descr->infoWidth, descr->width,
3609                                            descr->xSrc, (int *)(descr->colorMap),
3610                                            bmpImage, descr->dibpitch );
3611             break;
3612         case 15:
3613         case 16:
3614             X11DRV_DIB_SetImageBits_16( descr->lines, descr->bits,
3615                                         descr->infoWidth, descr->width,
3616                                         descr->xSrc, descr->physDev,
3617                                         descr->rMask, descr->gMask, descr->bMask,
3618                                         bmpImage, descr->dibpitch);
3619             break;
3620         case 24:
3621             X11DRV_DIB_SetImageBits_24( descr->lines, descr->bits,
3622                                         descr->infoWidth, descr->width,
3623                                         descr->xSrc, descr->physDev,
3624                                         descr->rMask, descr->gMask, descr->bMask,
3625                                         bmpImage, descr->dibpitch);
3626             break;
3627         case 32:
3628             X11DRV_DIB_SetImageBits_32( descr->lines, descr->bits,
3629                                         descr->infoWidth, descr->width,
3630                                         descr->xSrc, descr->physDev,
3631                                         descr->rMask, descr->gMask, descr->bMask,
3632                                         bmpImage, descr->dibpitch);
3633             break;
3634         default:
3635             WARN("(%d): Invalid depth\n", descr->infoBpp );
3636             break;
3637         }
3638     }
3639     __EXCEPT_PAGE_FAULT
3640     {
3641         WARN( "invalid bits pointer %p\n", descr->bits );
3642         lines = 0;
3643     }
3644     __ENDTRY
3645
3646     TRACE("XPutImage(%ld,%p,%p,%d,%d,%d,%d,%d,%d)\n",
3647      descr->drawable, descr->gc, bmpImage,
3648      descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
3649      descr->width, descr->height);
3650
3651     wine_tsx11_lock();
3652     if (lines)
3653     {
3654 #ifdef HAVE_LIBXXSHM
3655         if (descr->shm_mode == X11DRV_SHM_PIXMAP
3656                 && descr->xSrc == 0 && descr->ySrc == 0
3657                 && descr->xDest == 0 && descr->yDest == 0)
3658         {
3659             XSync( gdi_display, False );
3660         }
3661         else if (descr->shm_mode == X11DRV_SHM_IMAGE && descr->image)
3662         {
3663             XShmPutImage( gdi_display, descr->drawable, descr->gc, bmpImage,
3664                           descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
3665                           descr->width, descr->height, FALSE );
3666             XSync( gdi_display, 0 );
3667         }
3668         else
3669 #endif
3670         {
3671             XPutImage( gdi_display, descr->drawable, descr->gc, bmpImage,
3672                        descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
3673                        descr->width, descr->height );
3674         }
3675     }
3676
3677     if (old_data) descr->image->data = old_data;
3678
3679     if (!descr->image) X11DRV_DIB_DestroyXImage( bmpImage );
3680     wine_tsx11_unlock();
3681     return lines;
3682 }
3683
3684 /***********************************************************************
3685  *           X11DRV_DIB_GetImageBits
3686  *
3687  * Transfer the bits from an X image.
3688  */
3689 static int X11DRV_DIB_GetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
3690 {
3691     int lines = descr->lines >= 0 ? descr->lines : -descr->lines;
3692     void *old_data = NULL;
3693     XImage *bmpImage;
3694
3695     wine_tsx11_lock();
3696    if (descr->image)
3697         bmpImage = descr->image;
3698     else {
3699         bmpImage = XCreateImage( gdi_display, visual, descr->depth, ZPixmap, 0, NULL,
3700                                  descr->infoWidth, lines, 32, 0 );
3701         bmpImage->data = HeapAlloc( GetProcessHeap(), 0, lines * bmpImage->bytes_per_line );
3702         if(bmpImage->data == NULL) {
3703             ERR("Out of memory!\n");
3704             XDestroyImage( bmpImage );
3705             wine_tsx11_unlock();
3706             return 0;
3707         }
3708         if (descr->shifts)
3709         {
3710             bmpImage->red_mask = descr->shifts->physicalRed.max << descr->shifts->physicalRed.shift;
3711             bmpImage->green_mask = descr->shifts->physicalGreen.max << descr->shifts->physicalGreen.shift;
3712             bmpImage->blue_mask = descr->shifts->physicalBlue.max << descr->shifts->physicalBlue.shift;
3713         }
3714     }
3715
3716 #ifdef HAVE_LIBXXSHM
3717
3718     /* We must not call XShmGetImage() with a bitmap which is bigger than the available area.
3719        If we do, XShmGetImage() will fail (X exception), as it checks for this internally. */
3720     if (descr->shm_mode == X11DRV_SHM_PIXMAP && descr->image
3721             && descr->xSrc == 0 && descr->ySrc == 0
3722             && descr->xDest == 0 && descr->yDest == 0
3723             && bmpImage->width <= (descr->width - descr->xSrc)
3724             && bmpImage->height <= (descr->height - descr->ySrc))
3725     {
3726         XSync( gdi_display, False );
3727         old_data = bmpImage->data;
3728         bmpImage->data = descr->physBitmap->shminfo.shmaddr;
3729         TRACE("Using shared pixmap data.\n");
3730     }
3731     else if (descr->shm_mode == X11DRV_SHM_IMAGE && descr->image
3732             && bmpImage->width <= (descr->width - descr->xSrc)
3733             && bmpImage->height <= (descr->height - descr->ySrc))
3734     {
3735         int saveRed, saveGreen, saveBlue;
3736
3737         TRACE("XShmGetImage(%p, %ld, %p, %d, %d, %ld)\n",
3738                             gdi_display, descr->drawable, bmpImage,
3739                             descr->xSrc, descr->ySrc, AllPlanes);
3740
3741         /* We must save and restore the bmpImage's masks in order
3742          * to preserve them across the call to XShmGetImage, which
3743          * decides to eliminate them since it doesn't happen to know
3744          * what the format of the image is supposed to be, even though
3745          * we do. */
3746         saveRed = bmpImage->red_mask;
3747         saveBlue= bmpImage->blue_mask;
3748         saveGreen = bmpImage->green_mask;
3749
3750         XShmGetImage( gdi_display, descr->drawable, bmpImage,
3751                       descr->xSrc, descr->ySrc, AllPlanes);
3752
3753         bmpImage->red_mask = saveRed;
3754         bmpImage->blue_mask = saveBlue;
3755         bmpImage->green_mask = saveGreen;
3756     }
3757     else
3758 #endif /* HAVE_LIBXXSHM */
3759     {
3760         TRACE("XGetSubImage(%p,%ld,%d,%d,%d,%d,%ld,%d,%p,%d,%d)\n",
3761               gdi_display, descr->drawable, descr->xSrc, descr->ySrc, descr->width,
3762               lines, AllPlanes, ZPixmap, bmpImage, descr->xDest, descr->yDest);
3763         XGetSubImage( gdi_display, descr->drawable, descr->xSrc, descr->ySrc,
3764                       descr->width, lines, AllPlanes, ZPixmap,
3765                       bmpImage, descr->xDest, descr->yDest );
3766     }
3767     wine_tsx11_unlock();
3768
3769     TRACE("Dib: depth=%2d r=%x g=%x b=%x\n",
3770           descr->infoBpp,descr->rMask,descr->gMask,descr->bMask);
3771     TRACE("Bmp: depth=%2d/%2d r=%lx g=%lx b=%lx\n",
3772           bmpImage->depth,bmpImage->bits_per_pixel,
3773           bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
3774       /* Transfer the pixels */
3775     switch(descr->infoBpp)
3776     {
3777     case 1:
3778           X11DRV_DIB_GetImageBits_1( descr->lines,(LPVOID)descr->bits,
3779                                      descr->infoWidth, descr->width,
3780                                      descr->colorMap, descr->palentry,
3781                                      bmpImage, descr->dibpitch );
3782        break;
3783
3784     case 4:
3785         if (descr->compression) {
3786            FIXME("Compression not yet supported!\n");
3787            if(descr->sizeImage < X11DRV_DIB_GetDIBWidthBytes( descr->infoWidth, 4 ) * abs(descr->lines))
3788                break;
3789         }
3790         X11DRV_DIB_GetImageBits_4( descr->lines,(LPVOID)descr->bits,
3791                                    descr->infoWidth, descr->width,
3792                                    descr->colorMap, descr->palentry,
3793                                    bmpImage, descr->dibpitch );
3794         break;
3795     case 8:
3796         if (descr->compression) {
3797            FIXME("Compression not yet supported!\n");
3798            if(descr->sizeImage < X11DRV_DIB_GetDIBWidthBytes( descr->infoWidth, 8 ) * abs(descr->lines))
3799                break;
3800         }
3801         X11DRV_DIB_GetImageBits_8( descr->lines, (LPVOID)descr->bits,
3802                                    descr->infoWidth, descr->width,
3803                                    descr->colorMap, descr->palentry,
3804                                    bmpImage, descr->dibpitch );
3805         break;
3806     case 15:
3807     case 16:
3808        X11DRV_DIB_GetImageBits_16( descr->physDev, descr->lines, (LPVOID)descr->bits,
3809                                    descr->infoWidth,descr->width,
3810                                    descr->palentry,
3811                                    descr->rMask, descr->gMask, descr->bMask,
3812                                    bmpImage, descr->dibpitch );
3813        break;
3814
3815     case 24:
3816        X11DRV_DIB_GetImageBits_24( descr->physDev, descr->lines, (LPVOID)descr->bits,
3817                                    descr->infoWidth,descr->width,
3818                                    descr->palentry,
3819                                    descr->rMask, descr->gMask, descr->bMask,
3820                                    bmpImage, descr->dibpitch);
3821        break;
3822
3823     case 32:
3824        X11DRV_DIB_GetImageBits_32( descr->physDev, descr->lines, (LPVOID)descr->bits,
3825                                    descr->infoWidth, descr->width,
3826                                    descr->palentry,
3827                                    descr->rMask, descr->gMask, descr->bMask,
3828                                    bmpImage, descr->dibpitch);
3829        break;
3830
3831     default:
3832         WARN("(%d): Invalid depth\n", descr->infoBpp );
3833         break;
3834     }
3835
3836     if (old_data) bmpImage->data = old_data;
3837     if (!descr->image) X11DRV_DIB_DestroyXImage( bmpImage );
3838     return lines;
3839 }
3840
3841 /*************************************************************************
3842  *              X11DRV_SetDIBitsToDevice
3843  *
3844  */
3845 INT CDECL X11DRV_SetDIBitsToDevice( X11DRV_PDEVICE *physDev, INT xDest, INT yDest, DWORD cx,
3846                                     DWORD cy, INT xSrc, INT ySrc,
3847                                     UINT startscan, UINT lines, LPCVOID bits,
3848                                     const BITMAPINFO *info, UINT coloruse )
3849 {
3850     X11DRV_DIB_IMAGEBITS_DESCR descr;
3851     INT result;
3852     LONG width, height;
3853     BOOL top_down;
3854     POINT pt;
3855     int rop = X11DRV_XROPfunction[GetROP2(physDev->hdc) - 1];
3856
3857     if (DIB_GetBitmapInfo( &info->bmiHeader, &width, &height,
3858                            &descr.infoBpp, &descr.compression ) == -1)
3859         return 0;
3860
3861     top_down = (height < 0);
3862     if (top_down) height = -height;
3863
3864     pt.x = xDest;
3865     pt.y = yDest;
3866     LPtoDP(physDev->hdc, &pt, 1);
3867
3868     if (!lines || (startscan >= height)) return 0;
3869     if (!top_down && startscan + lines > height) lines = height - startscan;
3870
3871     /* make xSrc,ySrc point to the upper-left corner, not the lower-left one,
3872      * and clamp all values to fit inside [startscan,startscan+lines]
3873      */
3874     if (ySrc + cy <= startscan + lines)
3875     {
3876         UINT y = startscan + lines - (ySrc + cy);
3877         if (ySrc < startscan) cy -= (startscan - ySrc);
3878         if (!top_down)
3879         {
3880             /* avoid getting unnecessary lines */
3881             ySrc = 0;
3882             if (y >= lines) return 0;
3883             lines -= y;
3884         }
3885         else
3886         {
3887             if (y >= lines) return lines;
3888             ySrc = y;  /* need to get all lines in top down mode */
3889         }
3890     }
3891     else
3892     {
3893         if (ySrc >= startscan + lines) return lines;
3894         pt.y += ySrc + cy - (startscan + lines);
3895         cy = startscan + lines - ySrc;
3896         ySrc = 0;
3897         if (cy > lines) cy = lines;
3898     }
3899     if (xSrc >= width) return lines;
3900     if (xSrc + cx >= width) cx = width - xSrc;
3901     if (!cx || !cy) return lines;
3902
3903     /* Update the pixmap from the DIB section */
3904     X11DRV_LockDIBSection(physDev, DIB_Status_GdiMod);
3905
3906     X11DRV_SetupGCForText( physDev );  /* To have the correct colors */
3907     wine_tsx11_lock();
3908     XSetFunction(gdi_display, physDev->gc, rop);
3909     wine_tsx11_unlock();
3910
3911     switch (descr.infoBpp)
3912     {
3913        case 1:
3914        case 4:
3915        case 8:
3916                descr.colorMap = (RGBQUAD *)X11DRV_DIB_BuildColorMap(
3917                                             physDev, coloruse,
3918                                             physDev->depth, info, &descr.nColorMap );
3919                if (!descr.colorMap) return 0;
3920                descr.rMask = descr.gMask = descr.bMask = 0;
3921                break;
3922        case 15:
3923        case 16:
3924                descr.rMask = (descr.compression == BI_BITFIELDS) ? *(const DWORD *)info->bmiColors       : 0x7c00;
3925                descr.gMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 1) : 0x03e0;
3926                descr.bMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 2) : 0x001f;
3927                descr.colorMap = 0;
3928                break;
3929
3930        case 24:
3931        case 32:
3932                descr.rMask = (descr.compression == BI_BITFIELDS) ? *(const DWORD *)info->bmiColors       : 0xff0000;
3933                descr.gMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 1) : 0x00ff00;
3934                descr.bMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 2) : 0x0000ff;
3935                descr.colorMap = 0;
3936                break;
3937     }
3938
3939     descr.physDev    = physDev;
3940     descr.bits       = bits;
3941     descr.image      = NULL;
3942     descr.palentry   = NULL;
3943     descr.lines      = top_down ? -lines : lines;
3944     descr.infoWidth  = width;
3945     descr.depth      = physDev->depth;
3946     descr.shifts     = physDev->color_shifts;
3947     descr.drawable   = physDev->drawable;
3948     descr.gc         = physDev->gc;
3949     descr.xSrc       = xSrc;
3950     descr.ySrc       = ySrc;
3951     descr.xDest      = physDev->dc_rect.left + pt.x;
3952     descr.yDest      = physDev->dc_rect.top + pt.y;
3953     descr.width      = cx;
3954     descr.height     = cy;
3955     descr.shm_mode   = X11DRV_SHM_NONE;
3956     descr.dibpitch   = ((width * descr.infoBpp + 31) &~31) / 8;
3957     descr.physBitmap = NULL;
3958
3959     result = X11DRV_DIB_SetImageBits( &descr );
3960
3961     if (descr.infoBpp <= 8)
3962        HeapFree(GetProcessHeap(), 0, descr.colorMap);
3963
3964     /* Update the DIBSection of the pixmap */
3965     X11DRV_UnlockDIBSection(physDev, TRUE);
3966
3967     return result;
3968 }
3969
3970 /***********************************************************************
3971  *           SetDIBits   (X11DRV.@)
3972  */
3973 INT CDECL X11DRV_SetDIBits( X11DRV_PDEVICE *physDev, HBITMAP hbitmap, UINT startscan,
3974                             UINT lines, LPCVOID bits, const BITMAPINFO *info, UINT coloruse )
3975 {
3976   X_PHYSBITMAP *physBitmap = X11DRV_get_phys_bitmap( hbitmap );
3977   X11DRV_DIB_IMAGEBITS_DESCR descr;
3978   DIBSECTION ds;
3979   LONG width, height, tmpheight;
3980   INT result;
3981
3982   descr.physDev = physDev;
3983
3984   if (!physBitmap) return 0;
3985
3986   if (DIB_GetBitmapInfo( &info->bmiHeader, &width, &height,
3987                          &descr.infoBpp, &descr.compression ) == -1)
3988       return 0;
3989
3990   tmpheight = height;
3991   if (height < 0) height = -height;
3992   if (!lines || (startscan >= height))
3993       return 0;
3994
3995   if (!GetObjectW( hbitmap, sizeof(ds), &ds )) return 0;
3996
3997   if (startscan + lines > height) lines = height - startscan;
3998
3999   switch (descr.infoBpp)
4000   {
4001        case 1:
4002        case 4:
4003        case 8:
4004                descr.colorMap = (RGBQUAD *)X11DRV_DIB_BuildColorMap(
4005                                                           descr.physDev, coloruse,
4006                                                           physBitmap->pixmap_depth,
4007                                                           info, &descr.nColorMap );
4008                if (!descr.colorMap) return 0;
4009                descr.rMask = descr.gMask = descr.bMask = 0;
4010                break;
4011        case 15:
4012        case 16:
4013                descr.rMask = (descr.compression == BI_BITFIELDS) ? *(const DWORD *)info->bmiColors       : 0x7c00;
4014                descr.gMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 1) : 0x03e0;
4015                descr.bMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 2) : 0x001f;
4016                descr.colorMap = 0;
4017                break;
4018
4019        case 24:
4020        case 32:
4021                descr.rMask = (descr.compression == BI_BITFIELDS) ? *(const DWORD *)info->bmiColors       : 0xff0000;
4022                descr.gMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 1) : 0x00ff00;
4023                descr.bMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 2) : 0x0000ff;
4024                descr.colorMap = 0;
4025                break;
4026
4027        default: break;
4028   }
4029
4030   descr.bits       = bits;
4031   descr.image      = NULL;
4032   descr.palentry   = NULL;
4033   descr.infoWidth  = width;
4034   descr.lines      = tmpheight >= 0 ? lines : -lines;
4035   descr.depth      = physBitmap->pixmap_depth;
4036   descr.shifts     = physBitmap->trueColor ? &physBitmap->pixmap_color_shifts : NULL;
4037   descr.drawable   = physBitmap->pixmap;
4038   descr.gc         = get_bitmap_gc(physBitmap->pixmap_depth);
4039   descr.xSrc       = 0;
4040   descr.ySrc       = 0;
4041   descr.xDest      = 0;
4042   descr.yDest      = height - startscan - lines;
4043   descr.width      = ds.dsBm.bmWidth;
4044   descr.height     = lines;
4045   descr.shm_mode   = X11DRV_SHM_NONE;
4046   descr.dibpitch   = ((descr.infoWidth * descr.infoBpp + 31) &~31) / 8;
4047   descr.physBitmap = NULL;
4048   X11DRV_DIB_Lock( physBitmap, DIB_Status_GdiMod );
4049   result = X11DRV_DIB_SetImageBits( &descr );
4050
4051   /* optimisation for the case where the input bits are in exactly the same
4052    * format as the internal representation and copying to the app bits is
4053    * cheap - saves a round trip to the X server */
4054   if (descr.compression == BI_RGB &&
4055       coloruse == DIB_RGB_COLORS &&
4056       descr.infoBpp == ds.dsBm.bmBitsPixel &&
4057       physBitmap->base && physBitmap->size < 65536)
4058   {
4059       unsigned int srcwidthb = X11DRV_DIB_GetDIBWidthBytes( width, descr.infoBpp );
4060       int dstwidthb = ds.dsBm.bmWidthBytes;
4061       LPBYTE dbits = physBitmap->base + startscan * dstwidthb;
4062       const BYTE *sbits = bits;
4063       int widthb;
4064       UINT y;
4065
4066       TRACE("syncing compatible set bits to app bits\n");
4067       if ((tmpheight < 0) ^ physBitmap->topdown)
4068       {
4069           dbits += dstwidthb * (lines-1);
4070           dstwidthb = -dstwidthb;
4071       }
4072       X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
4073       widthb = min(srcwidthb, abs(dstwidthb));
4074       for (y = 0; y < lines; y++, dbits += dstwidthb, sbits += srcwidthb)
4075           memcpy(dbits, sbits, widthb);
4076       X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READONLY );
4077       physBitmap->status = DIB_Status_InSync;
4078   }
4079   X11DRV_DIB_Unlock( physBitmap, TRUE );
4080
4081   HeapFree(GetProcessHeap(), 0, descr.colorMap);
4082
4083   return result;
4084 }
4085
4086 /***********************************************************************
4087  *           GetDIBits   (X11DRV.@)
4088  */
4089 INT CDECL X11DRV_GetDIBits( X11DRV_PDEVICE *physDev, HBITMAP hbitmap, UINT startscan, UINT lines,
4090                             LPVOID bits, BITMAPINFO *info, UINT coloruse )
4091 {
4092   X_PHYSBITMAP *physBitmap = X11DRV_get_phys_bitmap( hbitmap );
4093   DIBSECTION dib;
4094   X11DRV_DIB_IMAGEBITS_DESCR descr;
4095   PALETTEENTRY palette[256];
4096   size_t obj_size;
4097   int height;
4098   LONG width, tempHeight;
4099   int bitmap_type;
4100   BOOL core_header;
4101   void* colorPtr;
4102   static const PALETTEENTRY peBlack = {0,0,0,0};
4103   static const PALETTEENTRY peWhite = {255,255,255,0};
4104
4105   if (!physBitmap) return 0;
4106   if (!(obj_size = GetObjectW( hbitmap, sizeof(dib), &dib ))) return 0;
4107
4108   bitmap_type = DIB_GetBitmapInfo( (BITMAPINFOHEADER*)info, &width, &tempHeight, &descr.infoBpp, &descr.compression);
4109   if (bitmap_type == -1)
4110   {
4111       ERR("Invalid bitmap\n");
4112       return 0;
4113   }
4114
4115   if (physBitmap->pixmap_depth > 1)
4116   {
4117     GetPaletteEntries( GetCurrentObject( physDev->hdc, OBJ_PAL ), 0, 256, palette );
4118   }
4119   else
4120   {
4121     palette[0] = peBlack;
4122     palette[1] = peWhite;
4123   }
4124
4125   descr.lines = tempHeight;
4126   core_header = (bitmap_type == 0);
4127   colorPtr = (LPBYTE) info + (WORD) info->bmiHeader.biSize;
4128
4129   TRACE("%u scanlines of (%i,%i) -> (%i,%i) starting from %u\n",
4130         lines, dib.dsBm.bmWidth, dib.dsBm.bmHeight, width, descr.lines, startscan);
4131
4132   if( lines > dib.dsBm.bmHeight ) lines = dib.dsBm.bmHeight;
4133
4134   height = descr.lines;
4135   if (height < 0) height = -height;
4136   if( lines > height ) lines = height;
4137   /* Top-down images have a negative biHeight, the scanlines of these images
4138    * were inverted in X11DRV_DIB_GetImageBits_xx
4139    * To prevent this we simply change the sign of lines
4140    * (the number of scan lines to copy).
4141    * Negative lines are correctly handled by X11DRV_DIB_GetImageBits_xx.
4142    */
4143   if( descr.lines < 0 && lines > 0) lines = -lines;
4144
4145   if( startscan >= dib.dsBm.bmHeight ) return 0;
4146
4147   descr.colorMap = NULL;
4148
4149   switch (descr.infoBpp)
4150   {
4151       case 1:
4152       case 4:
4153       case 8:
4154           descr.rMask= descr.gMask = descr.bMask = 0;
4155           if(coloruse == DIB_RGB_COLORS)
4156               descr.colorMap = colorPtr;
4157           else {
4158               int num_colors = 1 << descr.infoBpp, i;
4159               RGBQUAD *rgb;
4160               COLORREF colref;
4161               WORD *index = colorPtr;
4162               descr.colorMap = rgb = HeapAlloc(GetProcessHeap(), 0, num_colors * sizeof(RGBQUAD));
4163               for(i = 0; i < num_colors; i++, rgb++, index++) {
4164                   colref = X11DRV_PALETTE_ToLogical(physDev, X11DRV_PALETTE_ToPhysical(physDev, PALETTEINDEX(*index)));
4165                   rgb->rgbRed = GetRValue(colref);
4166                   rgb->rgbGreen = GetGValue(colref);
4167                   rgb->rgbBlue = GetBValue(colref);
4168                   rgb->rgbReserved = 0;
4169               }
4170           }
4171           break;
4172       case 15:
4173       case 16:
4174           descr.rMask = (descr.compression == BI_BITFIELDS) ? *(const DWORD *)info->bmiColors       : 0x7c00;
4175           descr.gMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 1) : 0x03e0;
4176           descr.bMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 2) : 0x001f;
4177           break;
4178       case 24:
4179       case 32:
4180           descr.rMask = (descr.compression == BI_BITFIELDS) ? *(const DWORD *)info->bmiColors       : 0xff0000;
4181           descr.gMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 1) : 0x00ff00;
4182           descr.bMask = (descr.compression == BI_BITFIELDS) ? *((const DWORD *)info->bmiColors + 2) : 0x0000ff;
4183           break;
4184   }
4185
4186   descr.physDev    = physDev;
4187   descr.palentry   = palette;
4188   descr.bits       = bits;
4189   descr.image      = physBitmap->image;
4190   descr.infoWidth  = width;
4191   descr.lines      = lines;
4192   descr.depth      = physBitmap->pixmap_depth;
4193   descr.shifts     = physBitmap->trueColor ? &physBitmap->pixmap_color_shifts : NULL;
4194   descr.drawable   = physBitmap->pixmap;
4195   descr.gc         = get_bitmap_gc(physBitmap->pixmap_depth);
4196   descr.width      = dib.dsBm.bmWidth;
4197   descr.height     = dib.dsBm.bmHeight;
4198   descr.xDest      = 0;
4199   descr.yDest      = 0;
4200   descr.xSrc       = 0;
4201   descr.sizeImage  = core_header ? 0 : info->bmiHeader.biSizeImage;
4202   descr.physBitmap = physBitmap;
4203
4204   if (descr.lines > 0)
4205   {
4206      descr.ySrc = (descr.height-1) - (startscan + (lines-1));
4207   }
4208   else
4209   {
4210      descr.ySrc = startscan;
4211   }
4212   descr.shm_mode = physBitmap->shm_mode;
4213   descr.dibpitch = (obj_size == sizeof(DIBSECTION)) ? dib.dsBm.bmWidthBytes
4214                        : (((descr.infoWidth * descr.infoBpp + 31) &~31) / 8);
4215
4216   X11DRV_DIB_Lock( physBitmap, DIB_Status_GdiMod );
4217   X11DRV_DIB_GetImageBits( &descr );
4218   X11DRV_DIB_Unlock( physBitmap, TRUE );
4219
4220   if(!core_header && info->bmiHeader.biSizeImage == 0) /* Fill in biSizeImage */
4221       info->bmiHeader.biSizeImage = X11DRV_DIB_GetDIBImageBytes( descr.infoWidth,
4222                                                                  descr.lines,
4223                                                                  descr.infoBpp);
4224
4225   if (descr.compression == BI_BITFIELDS)
4226   {
4227     *(DWORD *)info->bmiColors       = descr.rMask;
4228     *((DWORD *)info->bmiColors + 1) = descr.gMask;
4229     *((DWORD *)info->bmiColors + 2) = descr.bMask;
4230   }
4231   else if (!core_header)
4232   {
4233     /* if RLE or JPEG compression were supported,
4234      * this line would be invalid. */
4235     info->bmiHeader.biCompression = 0;
4236   }
4237
4238   if(descr.colorMap != colorPtr)
4239       HeapFree(GetProcessHeap(), 0, descr.colorMap);
4240   return lines;
4241 }
4242
4243 /***********************************************************************
4244  *           X11DRV_DIB_DoCopyDIBSection
4245  */
4246 static void X11DRV_DIB_DoCopyDIBSection(X_PHYSBITMAP *physBitmap, BOOL toDIB,
4247                                         void *colorMap, int nColorMap,
4248                                         Drawable dest, GC gc,
4249                                         DWORD xSrc, DWORD ySrc,
4250                                         DWORD xDest, DWORD yDest,
4251                                         DWORD width, DWORD height)
4252 {
4253   DIBSECTION dibSection;
4254   X11DRV_DIB_IMAGEBITS_DESCR descr;
4255   int identity[2] = {0,1};
4256
4257   if (!GetObjectW( physBitmap->hbitmap, sizeof(dibSection), &dibSection )) return;
4258
4259   descr.physDev     = NULL;
4260   descr.palentry    = NULL;
4261   descr.infoWidth   = dibSection.dsBmih.biWidth;
4262   descr.infoBpp     = dibSection.dsBmih.biBitCount;
4263   descr.lines       = physBitmap->topdown ? -dibSection.dsBmih.biHeight : dibSection.dsBmih.biHeight;
4264   descr.image       = physBitmap->image;
4265   descr.colorMap    = colorMap;
4266   descr.nColorMap   = nColorMap;
4267   descr.bits        = dibSection.dsBm.bmBits;
4268   descr.depth       = physBitmap->pixmap_depth;
4269   descr.shifts      = physBitmap->trueColor ? &physBitmap->pixmap_color_shifts : NULL;
4270   descr.compression = dibSection.dsBmih.biCompression;
4271   descr.physBitmap  = physBitmap;
4272
4273   if(descr.infoBpp == 1)
4274       descr.colorMap = (void*)identity;
4275
4276   switch (descr.infoBpp)
4277   {
4278     case 1:
4279     case 4:
4280     case 8:
4281       descr.rMask = descr.gMask = descr.bMask = 0;
4282       break;
4283     case 15:
4284     case 16:
4285       descr.rMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[0] : 0x7c00;
4286       descr.gMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[1] : 0x03e0;
4287       descr.bMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[2] : 0x001f;
4288       break;
4289
4290     case 24:
4291     case 32:
4292       descr.rMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[0] : 0xff0000;
4293       descr.gMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[1] : 0x00ff00;
4294       descr.bMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[2] : 0x0000ff;
4295       break;
4296   }
4297
4298   /* Hack for now */
4299   descr.drawable  = dest;
4300   descr.gc        = gc;
4301   descr.xSrc      = xSrc;
4302   descr.ySrc      = ySrc;
4303   descr.xDest     = xDest;
4304   descr.yDest     = yDest;
4305   descr.width     = width;
4306   descr.height    = height;
4307   descr.sizeImage = 0;
4308
4309   descr.shm_mode = physBitmap->shm_mode;
4310 #ifdef HAVE_LIBXXSHM
4311   if (physBitmap->shm_mode == X11DRV_SHM_PIXMAP && physBitmap->pixmap != dest)
4312   {
4313     descr.shm_mode = X11DRV_SHM_NONE;
4314   }
4315 #endif
4316   descr.dibpitch = dibSection.dsBm.bmWidthBytes;
4317
4318   if (toDIB)
4319     {
4320       TRACE("Copying from Pixmap to DIB bits\n");
4321       X11DRV_DIB_GetImageBits( &descr );
4322     }
4323   else
4324     {
4325       TRACE("Copying from DIB bits to Pixmap\n");
4326       X11DRV_DIB_SetImageBits( &descr );
4327     }
4328 }
4329
4330 /***********************************************************************
4331  *           X11DRV_DIB_CopyDIBSection
4332  */
4333 void X11DRV_DIB_CopyDIBSection(X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
4334                                DWORD xSrc, DWORD ySrc, DWORD xDest, DWORD yDest,
4335                                DWORD width, DWORD height)
4336 {
4337   DIBSECTION dib;
4338   X_PHYSBITMAP *physBitmap;
4339   unsigned int nColorMap;
4340   int* x11ColorMap;
4341   int freeColorMap;
4342
4343   TRACE("(%p,%p,%d,%d,%d,%d,%d,%d)\n", physDevSrc->hdc, physDevDst->hdc,
4344     xSrc, ySrc, xDest, yDest, width, height);
4345   /* this function is meant as an optimization for BitBlt,
4346    * not to be called otherwise */
4347   physBitmap = physDevSrc->bitmap;
4348   if (!physBitmap || GetObjectW( physBitmap->hbitmap, sizeof(dib), &dib ) != sizeof(dib))
4349   {
4350     ERR("called for non-DIBSection!?\n");
4351     return;
4352   }
4353   /* while BitBlt should already have made sure we only get
4354    * positive values, we should check for oversize values */
4355   if ((xSrc < dib.dsBm.bmWidth) &&
4356       (ySrc < dib.dsBm.bmHeight)) {
4357     if (xSrc + width > dib.dsBm.bmWidth)
4358       width = dib.dsBm.bmWidth - xSrc;
4359     if (ySrc + height > dib.dsBm.bmHeight)
4360       height = dib.dsBm.bmHeight - ySrc;
4361     /* if the source bitmap is 8bpp or less, we're supposed to use the
4362      * DC's palette for color conversion (not the DIB color table) */
4363     if (dib.dsBm.bmBitsPixel <= 8) {
4364       HPALETTE hPalette = GetCurrentObject( physDevSrc->hdc, OBJ_PAL );
4365       if (!hPalette || (hPalette == GetStockObject(DEFAULT_PALETTE))) {
4366         /* HACK: no palette has been set in the source DC,
4367          * use the DIB colormap instead - this is necessary in some
4368          * cases since we need to do depth conversion in some places
4369          * where real Windows can just copy data straight over */
4370         x11ColorMap = physBitmap->colorMap;
4371         nColorMap = physBitmap->nColorMap;
4372         freeColorMap = FALSE;
4373       } else {
4374           const BITMAPINFO* info = (BITMAPINFO*)&dib.dsBmih;
4375           unsigned int i;
4376
4377           nColorMap = X11DRV_DIB_GetColorCount(info);
4378           x11ColorMap = HeapAlloc(GetProcessHeap(), 0, nColorMap * sizeof(int));
4379           for (i = 0; i < nColorMap; i++)
4380               x11ColorMap[i] = X11DRV_PALETTE_ToPhysical(physDevSrc, PALETTEINDEX(i));
4381           freeColorMap = TRUE;
4382       }
4383     }
4384     else
4385     {
4386         nColorMap = 0;
4387         x11ColorMap = NULL;
4388         freeColorMap = FALSE;
4389     }
4390     /* perform the copy */
4391     X11DRV_DIB_DoCopyDIBSection(physBitmap, FALSE, x11ColorMap, nColorMap,
4392                                 physDevDst->drawable, physDevDst->gc, xSrc, ySrc,
4393                                 physDevDst->dc_rect.left + xDest, physDevDst->dc_rect.top + yDest,
4394                                 width, height);
4395     /* free color mapping */
4396     if (freeColorMap)
4397       HeapFree(GetProcessHeap(), 0, x11ColorMap);
4398   }
4399 }
4400
4401 /***********************************************************************
4402  *           X11DRV_DIB_DoUpdateDIBSection
4403  */
4404 static void X11DRV_DIB_DoUpdateDIBSection(X_PHYSBITMAP *physBitmap, BOOL toDIB)
4405 {
4406     BITMAP bitmap;
4407
4408     GetObjectW( physBitmap->hbitmap, sizeof(bitmap), &bitmap );
4409     X11DRV_DIB_DoCopyDIBSection(physBitmap, toDIB,
4410                                 physBitmap->colorMap, physBitmap->nColorMap,
4411                                 physBitmap->pixmap, get_bitmap_gc(physBitmap->pixmap_depth),
4412                                 0, 0, 0, 0, bitmap.bmWidth, bitmap.bmHeight);
4413 }
4414
4415 /***********************************************************************
4416  *           X11DRV_DIB_FaultHandler
4417  */
4418 static LONG CALLBACK X11DRV_DIB_FaultHandler( PEXCEPTION_POINTERS ep )
4419 {
4420     X_PHYSBITMAP *physBitmap = NULL;
4421     BOOL found = FALSE;
4422     BYTE *addr;
4423     struct list *ptr;
4424     const size_t pagemask = getpagesize() - 1;
4425
4426     if (ep->ExceptionRecord->ExceptionCode != EXCEPTION_ACCESS_VIOLATION)
4427         return EXCEPTION_CONTINUE_SEARCH;
4428
4429     addr = (BYTE *)ep->ExceptionRecord->ExceptionInformation[1];
4430
4431     EnterCriticalSection(&dibs_cs);
4432     LIST_FOR_EACH( ptr, &dibs_list )
4433     {
4434         physBitmap = LIST_ENTRY( ptr, X_PHYSBITMAP, entry );
4435         if ((physBitmap->base <= addr) &&
4436             (addr < physBitmap->base + ((physBitmap->size + pagemask) & ~pagemask)))
4437         {
4438             found = TRUE;
4439             break;
4440         }
4441     }
4442     LeaveCriticalSection(&dibs_cs);
4443
4444     if (!found) return EXCEPTION_CONTINUE_SEARCH;
4445
4446     if (addr >= physBitmap->base + physBitmap->size)
4447         WARN( "%p: access to %p beyond the end of the DIB\n", physBitmap->hbitmap, addr );
4448
4449     X11DRV_DIB_Lock( physBitmap, DIB_Status_None );
4450     if (ep->ExceptionRecord->ExceptionInformation[0] == EXCEPTION_WRITE_FAULT) {
4451         /* the app tried to write the DIB bits */
4452         X11DRV_DIB_Coerce( physBitmap, DIB_Status_AppMod);
4453     } else {
4454         /* the app tried to read the DIB bits */
4455         X11DRV_DIB_Coerce( physBitmap, DIB_Status_InSync);
4456     }
4457     X11DRV_DIB_Unlock( physBitmap, TRUE );
4458
4459     return EXCEPTION_CONTINUE_EXECUTION;
4460 }
4461
4462 /***********************************************************************
4463  *           X11DRV_DIB_Coerce
4464  */
4465 static INT X11DRV_DIB_Coerce(X_PHYSBITMAP *physBitmap, INT req)
4466 {
4467     INT ret = DIB_Status_None;
4468
4469     if (!physBitmap->image) return ret;  /* not a DIB section */
4470     EnterCriticalSection(&physBitmap->lock);
4471     ret = physBitmap->status;
4472     switch (req) {
4473     case DIB_Status_GdiMod:
4474       /* GDI access - request to draw on pixmap */
4475       switch (physBitmap->status)
4476       {
4477         default:
4478         case DIB_Status_None:
4479           physBitmap->p_status = DIB_Status_GdiMod;
4480           X11DRV_DIB_DoUpdateDIBSection( physBitmap, FALSE );
4481           break;
4482
4483         case DIB_Status_GdiMod:
4484           TRACE("GdiMod requested in status GdiMod\n" );
4485           physBitmap->p_status = DIB_Status_GdiMod;
4486           break;
4487
4488         case DIB_Status_InSync:
4489           TRACE("GdiMod requested in status InSync\n" );
4490           X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_NOACCESS );
4491           physBitmap->status = DIB_Status_GdiMod;
4492           physBitmap->p_status = DIB_Status_InSync;
4493           break;
4494
4495         case DIB_Status_AppMod:
4496           TRACE("GdiMod requested in status AppMod\n" );
4497           /* make it readonly to avoid app changing data while we copy */
4498           X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READONLY );
4499           X11DRV_DIB_DoUpdateDIBSection( physBitmap, FALSE );
4500           X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_NOACCESS );
4501           physBitmap->p_status = DIB_Status_AppMod;
4502           physBitmap->status = DIB_Status_GdiMod;
4503           break;
4504       }
4505       break;
4506
4507     case DIB_Status_InSync:
4508       /* App access - request access to read DIB surface */
4509       /* (typically called from signal handler) */
4510       switch (physBitmap->status)
4511       {
4512         default:
4513         case DIB_Status_None:
4514           /* shouldn't happen from signal handler */
4515           break;
4516
4517         case DIB_Status_GdiMod:
4518           TRACE("InSync requested in status GdiMod\n" );
4519           X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
4520           X11DRV_DIB_DoUpdateDIBSection( physBitmap, TRUE );
4521           X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READONLY );
4522           physBitmap->status = DIB_Status_InSync;
4523           break;
4524
4525         case DIB_Status_InSync:
4526           TRACE("InSync requested in status InSync\n" );
4527           /* shouldn't happen from signal handler */
4528           break;
4529
4530         case DIB_Status_AppMod:
4531           TRACE("InSync requested in status AppMod\n" );
4532           /* no reason to do anything here, and this
4533            * shouldn't happen from signal handler */
4534           break;
4535       }
4536       break;
4537
4538     case DIB_Status_AppMod:
4539       /* App access - request access to write DIB surface */
4540       /* (typically called from signal handler) */
4541       switch (physBitmap->status)
4542       {
4543         default:
4544         case DIB_Status_None:
4545           /* shouldn't happen from signal handler */
4546           break;
4547
4548         case DIB_Status_GdiMod:
4549           TRACE("AppMod requested in status GdiMod\n" );
4550           X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
4551           X11DRV_DIB_DoUpdateDIBSection( physBitmap, TRUE );
4552           physBitmap->status = DIB_Status_AppMod;
4553           break;
4554
4555         case DIB_Status_InSync:
4556           TRACE("AppMod requested in status InSync\n" );
4557           X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
4558           physBitmap->status = DIB_Status_AppMod;
4559           break;
4560
4561         case DIB_Status_AppMod:
4562           TRACE("AppMod requested in status AppMod\n" );
4563           /* shouldn't happen from signal handler */
4564           break;
4565       }
4566       break;
4567
4568       /* it is up to the caller to do the copy/conversion, probably
4569        * using the return value to decide where to copy from */
4570     }
4571     LeaveCriticalSection(&physBitmap->lock);
4572     return ret;
4573 }
4574
4575 /***********************************************************************
4576  *           X11DRV_DIB_Lock
4577  */
4578 static INT X11DRV_DIB_Lock(X_PHYSBITMAP *physBitmap, INT req)
4579 {
4580     INT ret = DIB_Status_None;
4581
4582     if (!physBitmap->image) return ret;  /* not a DIB section */
4583     TRACE("Locking %p from thread %04x\n", physBitmap->hbitmap, GetCurrentThreadId());
4584     EnterCriticalSection(&physBitmap->lock);
4585     ret = physBitmap->status;
4586     if (req != DIB_Status_None)
4587       X11DRV_DIB_Coerce(physBitmap, req);
4588     return ret;
4589 }
4590
4591 /***********************************************************************
4592  *           X11DRV_DIB_Unlock
4593  */
4594 static void X11DRV_DIB_Unlock(X_PHYSBITMAP *physBitmap, BOOL commit)
4595 {
4596     if (!physBitmap->image) return;  /* not a DIB section */
4597     switch (physBitmap->status)
4598     {
4599       default:
4600       case DIB_Status_None:
4601         /* in case anyone is wondering, this is the "signal handler doesn't
4602          * work" case, where we always have to be ready for app access */
4603         if (commit) {
4604           switch (physBitmap->p_status)
4605           {
4606             case DIB_Status_GdiMod:
4607               TRACE("Unlocking and syncing from GdiMod\n" );
4608               X11DRV_DIB_DoUpdateDIBSection( physBitmap, TRUE );
4609               break;
4610
4611             default:
4612               TRACE("Unlocking without needing to sync\n" );
4613               break;
4614           }
4615         }
4616         else TRACE("Unlocking with no changes\n");
4617         physBitmap->p_status = DIB_Status_None;
4618         break;
4619
4620       case DIB_Status_GdiMod:
4621         TRACE("Unlocking in status GdiMod\n" );
4622         /* DIB was protected in Coerce */
4623         if (!commit) {
4624           /* no commit, revert to InSync if applicable */
4625           if ((physBitmap->p_status == DIB_Status_InSync) ||
4626               (physBitmap->p_status == DIB_Status_AppMod)) {
4627             X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READONLY );
4628             physBitmap->status = DIB_Status_InSync;
4629           }
4630         }
4631         break;
4632
4633       case DIB_Status_InSync:
4634         TRACE("Unlocking in status InSync\n" );
4635         /* DIB was already protected in Coerce */
4636         break;
4637
4638       case DIB_Status_AppMod:
4639         TRACE("Unlocking in status AppMod\n" );
4640         /* DIB was already protected in Coerce */
4641         /* this case is ordinary only called from the signal handler,
4642          * so we don't bother to check for !commit */
4643         break;
4644     }
4645     LeaveCriticalSection(&physBitmap->lock);
4646     TRACE("Unlocked %p\n", physBitmap->hbitmap);
4647 }
4648
4649 /***********************************************************************
4650  *           X11DRV_CoerceDIBSection
4651  */
4652 INT X11DRV_CoerceDIBSection(X11DRV_PDEVICE *physDev, INT req)
4653 {
4654     if (!physDev || !physDev->bitmap) return DIB_Status_None;
4655     return X11DRV_DIB_Coerce(physDev->bitmap, req);
4656 }
4657
4658 /***********************************************************************
4659  *           X11DRV_LockDIBSection
4660  */
4661 INT X11DRV_LockDIBSection(X11DRV_PDEVICE *physDev, INT req)
4662 {
4663     if (!physDev || !physDev->bitmap) return DIB_Status_None;
4664     return X11DRV_DIB_Lock(physDev->bitmap, req);
4665 }
4666
4667 /***********************************************************************
4668  *           X11DRV_UnlockDIBSection
4669  */
4670 void X11DRV_UnlockDIBSection(X11DRV_PDEVICE *physDev, BOOL commit)
4671 {
4672     if (!physDev || !physDev->bitmap) return;
4673     X11DRV_DIB_Unlock(physDev->bitmap, commit);
4674 }
4675
4676
4677 #ifdef HAVE_LIBXXSHM
4678 /***********************************************************************
4679  *           X11DRV_XShmErrorHandler
4680  *
4681  */
4682 static int XShmErrorHandler( Display *dpy, XErrorEvent *event, void *arg )
4683 {
4684     return 1;  /* FIXME: should check event contents */
4685 }
4686
4687 /***********************************************************************
4688  *           X11DRV_XShmCreateImage
4689  *
4690  */
4691 static XImage *X11DRV_XShmCreateImage( int width, int height, int bpp,
4692                                        XShmSegmentInfo* shminfo)
4693 {
4694     XImage *image;
4695
4696     image = XShmCreateImage(gdi_display, visual, bpp, ZPixmap, NULL, shminfo, width, height);
4697     if (image)
4698     {
4699         shminfo->shmid = shmget(IPC_PRIVATE, image->bytes_per_line * height,
4700                                   IPC_CREAT|0700);
4701         if( shminfo->shmid != -1 )
4702         {
4703             shminfo->shmaddr = shmat( shminfo->shmid, 0, 0 );
4704             if( shminfo->shmaddr != (char*)-1 )
4705             {
4706                 BOOL ok;
4707
4708                 shminfo->readOnly = FALSE;
4709                 X11DRV_expect_error( gdi_display, XShmErrorHandler, NULL );
4710                 ok = (XShmAttach( gdi_display, shminfo ) != 0);
4711                 XSync( gdi_display, False );
4712                 if (X11DRV_check_error()) ok = FALSE;
4713                 if (ok)
4714                 {
4715                     shmctl(shminfo->shmid, IPC_RMID, 0);
4716                     return image; /* Success! */
4717                 }
4718                 /* An error occurred */
4719                 shmdt(shminfo->shmaddr);
4720             }
4721             shmctl(shminfo->shmid, IPC_RMID, 0);
4722             shminfo->shmid = -1;
4723         }
4724         XFlush(gdi_display);
4725         XDestroyImage(image);
4726         image = NULL;
4727     }
4728     return image;
4729 }
4730 #endif /* HAVE_LIBXXSHM */
4731
4732
4733 /***********************************************************************
4734  *           X11DRV_CreateDIBSection   (X11DRV.@)
4735  */
4736 HBITMAP CDECL X11DRV_CreateDIBSection( X11DRV_PDEVICE *physDev, HBITMAP hbitmap,
4737                                        const BITMAPINFO *bmi, UINT usage )
4738 {
4739     X_PHYSBITMAP *physBitmap;
4740     DIBSECTION dib;
4741     WORD bpp, compr;
4742     LONG w, h;
4743 #ifdef HAVE_LIBXXSHM
4744     int major, minor;
4745     Bool pixmaps;
4746 #endif
4747
4748     DIB_GetBitmapInfo( &bmi->bmiHeader, &w, &h, &bpp, &compr );
4749
4750     if (!(physBitmap = X11DRV_init_phys_bitmap( hbitmap ))) return 0;
4751     if (h < 0) physBitmap->topdown = TRUE;
4752     physBitmap->status = DIB_Status_None;
4753
4754     GetObjectW( hbitmap, sizeof(dib), &dib );
4755
4756     /* create color map */
4757     if (dib.dsBm.bmBitsPixel <= 8)
4758     {
4759         physBitmap->colorMap = X11DRV_DIB_BuildColorMap( physDev,
4760                                                          usage, dib.dsBm.bmBitsPixel, bmi,
4761                                                          &physBitmap->nColorMap );
4762     }
4763
4764     if (!X11DRV_XRender_SetPhysBitmapDepth( physBitmap, dib.dsBm.bmBitsPixel, &dib ))
4765     {
4766         if (dib.dsBm.bmBitsPixel == 1)
4767         {
4768             physBitmap->pixmap_depth = 1;
4769             physBitmap->trueColor = FALSE;
4770         }
4771         else
4772         {
4773             physBitmap->pixmap_depth = screen_depth;
4774             physBitmap->pixmap_color_shifts = X11DRV_PALETTE_default_shifts;
4775             physBitmap->trueColor = (visual->class == TrueColor || visual->class == DirectColor);
4776         }
4777     }
4778
4779     /* create pixmap and X image */
4780     wine_tsx11_lock();
4781 #ifdef HAVE_LIBXXSHM
4782     physBitmap->shminfo.shmid = -1;
4783
4784     if (XShmQueryVersion( gdi_display, &major, &minor, &pixmaps )
4785             && (physBitmap->image = X11DRV_XShmCreateImage( dib.dsBm.bmWidth, dib.dsBm.bmHeight,
4786                                                             physBitmap->pixmap_depth, &physBitmap->shminfo )))
4787     {
4788         if (pixmaps)
4789         {
4790             physBitmap->shm_mode = X11DRV_SHM_PIXMAP;
4791             physBitmap->image->data = HeapAlloc( GetProcessHeap(), 0,
4792                     dib.dsBm.bmHeight * physBitmap->image->bytes_per_line );
4793         }
4794         else
4795         {
4796             physBitmap->shm_mode = X11DRV_SHM_IMAGE;
4797             physBitmap->image->data = physBitmap->shminfo.shmaddr;
4798         }
4799     }
4800     else
4801 #endif
4802     {
4803         physBitmap->shm_mode = X11DRV_SHM_NONE;
4804         physBitmap->image = X11DRV_DIB_CreateXImage( dib.dsBm.bmWidth, dib.dsBm.bmHeight,
4805                                                      physBitmap->pixmap_depth );
4806     }
4807
4808 #ifdef HAVE_LIBXXSHM
4809     if (physBitmap->shm_mode == X11DRV_SHM_PIXMAP)
4810     {
4811         TRACE("Creating shared pixmap for bmp %p.\n", physBitmap->hbitmap);
4812         physBitmap->pixmap = XShmCreatePixmap( gdi_display, root_window,
4813                                                physBitmap->shminfo.shmaddr, &physBitmap->shminfo,
4814                                                dib.dsBm.bmWidth, dib.dsBm.bmHeight,
4815                                                physBitmap->pixmap_depth );
4816     }
4817     else
4818 #endif
4819     {
4820         physBitmap->pixmap = XCreatePixmap( gdi_display, root_window, dib.dsBm.bmWidth,
4821                                             dib.dsBm.bmHeight, physBitmap->pixmap_depth );
4822     }
4823
4824     wine_tsx11_unlock();
4825     if (!physBitmap->pixmap || !physBitmap->image) return 0;
4826
4827     if (physBitmap->trueColor)
4828     {
4829         ColorShifts *shifts = &physBitmap->pixmap_color_shifts;
4830
4831         /* When XRender is around and used, we also support dibsections in other formats like 16-bit. In these
4832          * cases we need to override the mask of XImages. The reason is that during XImage creation the masks are
4833          * derived from a 24-bit visual (no 16-bit ones are around when X runs at 24-bit). SetImageBits and other
4834          * functions rely on the color masks for proper color conversion, so we need to override the masks here. */
4835         physBitmap->image->red_mask = shifts->physicalRed.max << shifts->physicalRed.shift;
4836         physBitmap->image->green_mask = shifts->physicalGreen.max << shifts->physicalGreen.shift;
4837         physBitmap->image->blue_mask = shifts->physicalBlue.max << shifts->physicalBlue.shift;
4838     }
4839
4840       /* install fault handler */
4841     InitializeCriticalSection( &physBitmap->lock );
4842     physBitmap->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": X_PHYSBITMAP.lock");
4843
4844     physBitmap->base   = dib.dsBm.bmBits;
4845     physBitmap->size   = dib.dsBmih.biSizeImage;
4846     physBitmap->status = DIB_Status_AppMod;
4847
4848     if (!dibs_handler)
4849         dibs_handler = AddVectoredExceptionHandler( TRUE, X11DRV_DIB_FaultHandler );
4850     EnterCriticalSection( &dibs_cs );
4851     list_add_head( &dibs_list, &physBitmap->entry );
4852     LeaveCriticalSection( &dibs_cs );
4853
4854     X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
4855
4856     return hbitmap;
4857 }
4858
4859 /***********************************************************************
4860  *           X11DRV_DIB_DeleteDIBSection
4861  */
4862 void X11DRV_DIB_DeleteDIBSection(X_PHYSBITMAP *physBitmap, DIBSECTION *dib)
4863 {
4864   BOOL last;
4865
4866   EnterCriticalSection( &dibs_cs );
4867   list_remove( &physBitmap->entry );
4868   last = list_empty( &dibs_list );
4869   LeaveCriticalSection( &dibs_cs );
4870
4871   if (last)
4872   {
4873       RemoveVectoredExceptionHandler( dibs_handler );
4874       dibs_handler = NULL;
4875   }
4876
4877   if (dib->dshSection)
4878       X11DRV_DIB_Coerce(physBitmap, DIB_Status_InSync);
4879
4880   if (physBitmap->image)
4881   {
4882       wine_tsx11_lock();
4883 #ifdef HAVE_LIBXXSHM
4884       if (physBitmap->shminfo.shmid != -1)
4885       {
4886           XShmDetach( gdi_display, &(physBitmap->shminfo) );
4887           if (physBitmap->shm_mode == X11DRV_SHM_PIXMAP) X11DRV_DIB_DestroyXImage( physBitmap->image );
4888           else XDestroyImage( physBitmap->image );
4889           shmdt( physBitmap->shminfo.shmaddr );
4890           physBitmap->shminfo.shmid = -1;
4891           physBitmap->shm_mode = X11DRV_SHM_NONE;
4892       }
4893       else
4894 #endif
4895           X11DRV_DIB_DestroyXImage( physBitmap->image );
4896       wine_tsx11_unlock();
4897   }
4898
4899   HeapFree(GetProcessHeap(), 0, physBitmap->colorMap);
4900   physBitmap->lock.DebugInfo->Spare[0] = 0;
4901   DeleteCriticalSection(&physBitmap->lock);
4902 }
4903
4904 /***********************************************************************
4905  *           SetDIBColorTable   (X11DRV.@)
4906  */
4907 UINT CDECL X11DRV_SetDIBColorTable( X11DRV_PDEVICE *physDev, UINT start, UINT count, const RGBQUAD *colors )
4908 {
4909     DIBSECTION dib;
4910     UINT ret = 0;
4911     X_PHYSBITMAP *physBitmap = physDev->bitmap;
4912
4913     if (!physBitmap) return 0;
4914     GetObjectW( physBitmap->hbitmap, sizeof(dib), &dib );
4915
4916     if (physBitmap->colorMap && start < physBitmap->nColorMap) {
4917         UINT end = count + start;
4918         if (end > physBitmap->nColorMap) end = physBitmap->nColorMap;
4919         /*
4920          * Changing color table might change the mapping between
4921          * DIB colors and X11 colors and thus alter the visible state
4922          * of the bitmap object.
4923          */
4924         /*
4925          * FIXME we need to recalculate the pen, brush, text and bkgnd pixels here,
4926          * at least for a 1 bpp dibsection
4927          */
4928         X11DRV_DIB_Lock( physBitmap, DIB_Status_AppMod );
4929         X11DRV_DIB_GenColorMap( physDev, physBitmap->colorMap, DIB_RGB_COLORS,
4930                                 dib.dsBm.bmBitsPixel,
4931                                 TRUE, colors, start, end );
4932         X11DRV_DIB_Unlock( physBitmap, TRUE );
4933         ret = end - start;
4934     }
4935     return ret;
4936 }
4937
4938
4939 /***********************************************************************
4940  *           X11DRV_DIB_CreateDIBFromBitmap
4941  *
4942  *  Allocates a packed DIB and copies the bitmap data into it.
4943  */
4944 HGLOBAL X11DRV_DIB_CreateDIBFromBitmap(HDC hdc, HBITMAP hBmp)
4945 {
4946     BITMAP bmp;
4947     HGLOBAL hPackedDIB;
4948     LPBYTE pPackedDIB;
4949     LPBITMAPINFOHEADER pbmiHeader;
4950     unsigned int cDataSize, cPackedSize, OffsetBits;
4951     int nLinesCopied;
4952
4953     if (!GetObjectW( hBmp, sizeof(bmp), &bmp )) return 0;
4954
4955     /*
4956      * A packed DIB contains a BITMAPINFO structure followed immediately by
4957      * an optional color palette and the pixel data.
4958      */
4959
4960     /* Calculate the size of the packed DIB */
4961     cDataSize = X11DRV_DIB_GetDIBWidthBytes( bmp.bmWidth, bmp.bmBitsPixel ) * abs( bmp.bmHeight );
4962     cPackedSize = sizeof(BITMAPINFOHEADER)
4963                   + ( (bmp.bmBitsPixel <= 8) ? (sizeof(RGBQUAD) * (1 << bmp.bmBitsPixel)) : 0 )
4964                   + cDataSize;
4965     /* Get the offset to the bits */
4966     OffsetBits = cPackedSize - cDataSize;
4967
4968     /* Allocate the packed DIB */
4969     TRACE("\tAllocating packed DIB of size %d\n", cPackedSize);
4970     hPackedDIB = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE /*| GMEM_ZEROINIT*/,
4971                              cPackedSize );
4972     if ( !hPackedDIB )
4973     {
4974         WARN("Could not allocate packed DIB!\n");
4975         return 0;
4976     }
4977
4978     /* A packed DIB starts with a BITMAPINFOHEADER */
4979     pPackedDIB = GlobalLock(hPackedDIB);
4980     pbmiHeader = (LPBITMAPINFOHEADER)pPackedDIB;
4981
4982     /* Init the BITMAPINFOHEADER */
4983     pbmiHeader->biSize = sizeof(BITMAPINFOHEADER);
4984     pbmiHeader->biWidth = bmp.bmWidth;
4985     pbmiHeader->biHeight = bmp.bmHeight;
4986     pbmiHeader->biPlanes = 1;
4987     pbmiHeader->biBitCount = bmp.bmBitsPixel;
4988     pbmiHeader->biCompression = BI_RGB;
4989     pbmiHeader->biSizeImage = 0;
4990     pbmiHeader->biXPelsPerMeter = pbmiHeader->biYPelsPerMeter = 0;
4991     pbmiHeader->biClrUsed = 0;
4992     pbmiHeader->biClrImportant = 0;
4993
4994     /* Retrieve the DIB bits from the bitmap and fill in the
4995      * DIB color table if present */
4996
4997     nLinesCopied = GetDIBits(hdc,                       /* Handle to device context */
4998                              hBmp,                      /* Handle to bitmap */
4999                              0,                         /* First scan line to set in dest bitmap */
5000                              bmp.bmHeight,              /* Number of scan lines to copy */
5001                              pPackedDIB + OffsetBits,   /* [out] Address of array for bitmap bits */
5002                              (LPBITMAPINFO) pbmiHeader, /* [out] Address of BITMAPINFO structure */
5003                              0);                        /* RGB or palette index */
5004     GlobalUnlock(hPackedDIB);
5005
5006     /* Cleanup if GetDIBits failed */
5007     if (nLinesCopied != bmp.bmHeight)
5008     {
5009         TRACE("\tGetDIBits returned %d. Actual lines=%d\n", nLinesCopied, bmp.bmHeight);
5010         GlobalFree(hPackedDIB);
5011         hPackedDIB = 0;
5012     }
5013     return hPackedDIB;
5014 }
5015
5016
5017 /**************************************************************************
5018  *              X11DRV_DIB_CreateDIBFromPixmap
5019  *
5020  *  Allocates a packed DIB and copies the Pixmap data into it.
5021  *  The Pixmap passed in is deleted after the conversion.
5022  */
5023 HGLOBAL X11DRV_DIB_CreateDIBFromPixmap(Pixmap pixmap, HDC hdc)
5024 {
5025     HDC hdcMem;
5026     X_PHYSBITMAP *physBitmap;
5027     Pixmap orig_pixmap;
5028     HBITMAP hBmp = 0;
5029     HGLOBAL hPackedDIB = 0;
5030     Window root;
5031     int x,y;               /* Unused */
5032     unsigned border_width; /* Unused */
5033     unsigned int depth, width, height;
5034
5035     /* Get the Pixmap dimensions and bit depth */
5036     wine_tsx11_lock();
5037     if (!XGetGeometry(gdi_display, pixmap, &root, &x, &y, &width, &height,
5038                       &border_width, &depth)) depth = 0;
5039     wine_tsx11_unlock();
5040     if (!depth) return 0;
5041
5042     TRACE("\tPixmap properties: width=%d, height=%d, depth=%d\n",
5043           width, height, depth);
5044
5045     /*
5046      * Create an HBITMAP with the same dimensions and BPP as the pixmap,
5047      * and make it a container for the pixmap passed.
5048      */
5049     if (!(hBmp = CreateBitmap( width, height, 1, depth_to_bpp(depth), NULL ))) return 0;
5050
5051     /* force bitmap to be owned by a screen DC */
5052     hdcMem = CreateCompatibleDC( hdc );
5053     SelectObject( hdcMem, SelectObject( hdcMem, hBmp ));
5054     DeleteDC( hdcMem );
5055
5056     physBitmap = X11DRV_get_phys_bitmap( hBmp );
5057
5058     /* swap the new pixmap in */
5059     orig_pixmap = physBitmap->pixmap;
5060     physBitmap->pixmap = pixmap;
5061
5062     /*
5063      * Create a packed DIB from the Pixmap wrapper bitmap created above.
5064      * A packed DIB contains a BITMAPINFO structure followed immediately by
5065      * an optional color palette and the pixel data.
5066      */
5067     hPackedDIB = X11DRV_DIB_CreateDIBFromBitmap(hdc, hBmp);
5068
5069     /* we can now get rid of the HBITMAP and its original pixmap */
5070     physBitmap->pixmap = orig_pixmap;
5071     DeleteObject(hBmp);
5072
5073     TRACE("\tReturning packed DIB %p\n", hPackedDIB);
5074     return hPackedDIB;
5075 }
5076
5077
5078 /**************************************************************************
5079  *                 X11DRV_DIB_CreatePixmapFromDIB
5080  *
5081  *    Creates a Pixmap from a packed DIB
5082  */
5083 Pixmap X11DRV_DIB_CreatePixmapFromDIB( HGLOBAL hPackedDIB, HDC hdc )
5084 {
5085     Pixmap pixmap;
5086     X_PHYSBITMAP *physBitmap;
5087     HBITMAP hBmp;
5088     LPBITMAPINFO pbmi;
5089
5090     /* Create a DDB from the DIB */
5091
5092     pbmi = GlobalLock(hPackedDIB);
5093     hBmp = CreateDIBitmap(hdc, &pbmi->bmiHeader, CBM_INIT,
5094                           (LPBYTE)pbmi + bitmap_info_size( pbmi, DIB_RGB_COLORS ),
5095                           pbmi, DIB_RGB_COLORS);
5096     GlobalUnlock(hPackedDIB);
5097
5098     /* clear the physBitmap so that we can steal its pixmap */
5099     physBitmap = X11DRV_get_phys_bitmap( hBmp );
5100     pixmap = physBitmap->pixmap;
5101     physBitmap->pixmap = 0;
5102
5103     /* Delete the DDB we created earlier now that we have stolen its pixmap */
5104     DeleteObject(hBmp);
5105
5106     TRACE("Returning Pixmap %lx\n", pixmap);
5107     return pixmap;
5108 }