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
 105 /*
 106   Some of the following helper functions are duplicated in
 107   dlls/gdi/dib.c
 108 */
 109
 110 /***********************************************************************
 111  *           DIB_DoProtectDIBSection
 112  */
 113 static void X11DRV_DIB_DoProtectDIBSection( X_PHYSBITMAP *physBitmap, DWORD new_prot )
 114 {
 115     DWORD old_prot;
 116
 117     VirtualProtect(physBitmap->base, physBitmap->size, new_prot, &old_prot);
 118     TRACE("Changed protection from %d to %d\n", old_prot, new_prot);
 119 }
 120
 121 /***********************************************************************
 122  *           X11DRV_DIB_GetXImageWidthBytes
 123  *
 124  * Return the width of an X image in bytes
 125  */
 126 static inline int X11DRV_DIB_GetXImageWidthBytes( int width, int depth )
 127 {
 128     if (!depth || depth > 32) goto error;
 129
 130     if (!ximageDepthTable[depth-1])
 131     {
 132         XImage *testimage = XCreateImage( gdi_display, visual, depth,
 133                                           ZPixmap, 0, NULL, 1, 1, 32, 20 );
 134         if (testimage)
 135         {
 136             ximageDepthTable[depth-1] = testimage->bits_per_pixel;
 137             XDestroyImage( testimage );
 138         }
 139         else ximageDepthTable[depth-1] = -1;
 140     }
 141     if (ximageDepthTable[depth-1] != -1)
 142         return (4 * ((width * ximageDepthTable[depth-1] + 31) / 32));
 143
 144  error:
 145     WARN( "(%d): Unsupported depth\n", depth );
 146     return 4 * width;
 147 }
 148
 149
 150 /***********************************************************************
 151  *           X11DRV_DIB_GetDIBWidthBytes
 152  *
 153  * Return the width of a DIB bitmap in bytes. DIB bitmap data is 32-bit aligned.
 154  */
 155 static int X11DRV_DIB_GetDIBWidthBytes( int width, int depth )
 156 {
 157     return ((width * depth + 31) / 8) & ~3;
 158 }
 159
 160
 161 /***********************************************************************
 162  *           bitmap_info_size
 163  *
 164  * Return the size of the bitmap info structure including color table.
 165  */
 166 int bitmap_info_size( const BITMAPINFO * info, WORD coloruse )
 167 {
 168     unsigned int colors, size, masks = 0;
 169
 170     if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
 171     {
 172         const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)info;
 173         colors = (core->bcBitCount <= 8) ? 1 << core->bcBitCount : 0;
 174         return sizeof(BITMAPCOREHEADER) + colors *
 175              ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
 176     }
 177     else  /* assume BITMAPINFOHEADER */
 178     {
 179         colors = info->bmiHeader.biClrUsed;
 180         if (!colors && (info->bmiHeader.biBitCount <= 8))
 181             colors = 1 << info->bmiHeader.biBitCount;
 182         if (info->bmiHeader.biCompression == BI_BITFIELDS) masks = 3;
 183         size = max( info->bmiHeader.biSize, sizeof(BITMAPINFOHEADER) + masks * sizeof(DWORD) );
 184         return size + colors * ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
 185     }
 186 }
 187
 188
 189 /***********************************************************************
 190  *           X11DRV_DIB_CreateXImage
 191  *
 192  * Create an X image.
 193  */
 194 XImage *X11DRV_DIB_CreateXImage( int width, int height, int depth )
 195 {
 196     int width_bytes;
 197     XImage *image = NULL;
 198     void *data;
 199
 200     wine_tsx11_lock();
 201     width_bytes = X11DRV_DIB_GetXImageWidthBytes( width, depth );
 202     data = HeapAlloc( GetProcessHeap(), 0, height * width_bytes );
 203     if (data) image = XCreateImage( gdi_display, visual, depth, ZPixmap, 0,
 204                                     data, width, height, 32, width_bytes );
 205     if (!image) HeapFree( GetProcessHeap(), 0, data );
 206     wine_tsx11_unlock();
 207     return image;
 208 }
 209
 210
 211 /***********************************************************************
 212  *           X11DRV_DIB_DestroyXImage
 213  *
 214  * Destroy an X image created with X11DRV_DIB_CreateXImage.
 215  */
 216 void X11DRV_DIB_DestroyXImage( XImage *image )
 217 {
 218     HeapFree( GetProcessHeap(), 0, image->data );
 219     image->data = NULL;
 220     wine_tsx11_lock();
 221     XDestroyImage( image );
 222     wine_tsx11_unlock();
 223 }
 224
 225
 226 /***********************************************************************
 227  *           X11DRV_DIB_GetColorCount
 228  *
 229  * Computes the number of colors for the bitmap palette.
 230  * Should not be called for a >8-bit deep bitmap.
 231  */
 232 static unsigned int X11DRV_DIB_GetColorCount(const BITMAPINFO *info)
 233 {
 234     unsigned int colors = min( info->bmiHeader.biClrUsed, 256 );
 235     if (!colors) colors = 1 << info->bmiHeader.biBitCount;
 236     return colors;
 237 }
 238
 239
 240 static inline BOOL colour_is_brighter(RGBQUAD c1, RGBQUAD c2)
 241 {
 242     return (c1.rgbRed * c1.rgbRed + c1.rgbGreen * c1.rgbGreen + c1.rgbBlue * c1.rgbBlue) >
 243         (c2.rgbRed * c2.rgbRed + c2.rgbGreen * c2.rgbGreen + c2.rgbBlue * c2.rgbBlue);
 244 }
 245
 246 /***********************************************************************
 247  *           X11DRV_DIB_GenColorMap
 248  *
 249  * Fills the color map of a bitmap palette. Should not be called
 250  * for a >8-bit deep bitmap.
 251  */
 252 static int *X11DRV_DIB_GenColorMap( X11DRV_PDEVICE *physDev, int *colorMapping,
 253                                     WORD coloruse, WORD depth, const void *colorPtr, int start, int end )
 254 {
 255     int i;
 256
 257     if (coloruse == DIB_RGB_COLORS)
 258     {
 259         const RGBQUAD * rgb = colorPtr;
 260
 261         if (depth == 1)  /* Monochrome */
 262         {
 263             BOOL invert = FALSE;
 264             RGBQUAD table[2];
 265
 266             if (GetDIBColorTable( physDev->dev.hdc, 0, 2, table ) == 2)
 267                 invert = !colour_is_brighter(table[1], table[0]);
 268
 269             for (i = start; i < end; i++, rgb++)
 270                 colorMapping[i] = ((rgb->rgbRed + rgb->rgbGreen +
 271                                     rgb->rgbBlue > 255*3/2 && !invert) ||
 272                                    (rgb->rgbRed + rgb->rgbGreen +
 273                                     rgb->rgbBlue <= 255*3/2 && invert));
 274         }
 275         else
 276             for (i = start; i < end; i++, rgb++)
 277                 colorMapping[i] = X11DRV_PALETTE_LookupPixel(physDev->color_shifts, RGB(rgb->rgbRed,
 278                                                                                         rgb->rgbGreen,
 279                                                                                         rgb->rgbBlue));
 280     }
 281     else  /* DIB_PAL_COLORS */
 282     {
 283         const WORD * index = colorPtr;
 284
 285         for (i = start; i < end; i++, index++)
 286             colorMapping[i] = X11DRV_PALETTE_ToPhysical( physDev, PALETTEINDEX(*index) );
 287     }
 288
 289     return colorMapping;
 290 }
 291
 292 /***********************************************************************
 293  *           X11DRV_DIB_BuildColorMap
 294  *
 295  * Build the color map from the bitmap palette. Should not be called
 296  * for a >8-bit deep bitmap.
 297  */
 298 static int *X11DRV_DIB_BuildColorMap( X11DRV_PDEVICE *physDev, WORD coloruse, WORD depth,
 299                                       const BITMAPINFO *info, int *nColors )
 300 {
 301     const void *colorPtr;
 302     int *colorMapping;
 303
 304
 305     *nColors = X11DRV_DIB_GetColorCount(info);
 306     if (!*nColors) return NULL;
 307
 308     colorPtr = (const BYTE*)info + (WORD)info->bmiHeader.biSize;
 309     if (!(colorMapping = HeapAlloc(GetProcessHeap(), 0, *nColors * sizeof(int) )))
 310         return NULL;
 311
 312     return X11DRV_DIB_GenColorMap( physDev, colorMapping, coloruse, depth,
 313                                    colorPtr, 0, *nColors);
 314 }
 315
 316 /***********************************************************************
 317  *           X11DRV_DIB_MapColor
 318  */
 319 static int X11DRV_DIB_MapColor( int *physMap, int nPhysMap, int phys, int oldcol )
 320 {
 321     int color;
 322
 323     if ((oldcol < nPhysMap) && (physMap[oldcol] == phys))
 324         return oldcol;
 325
 326     for (color = 0; color < nPhysMap; color++)
 327         if (physMap[color] == phys)
 328             return color;
 329
 330     WARN("Strange color %08x\n", phys);
 331     return 0;
 332 }
 333
 334
 335 /*********************************************************************
 336  *         X11DRV_DIB_GetNearestIndex
 337  *
 338  * Helper for X11DRV_DIB_GetDIBits.
 339  * Returns the nearest colour table index for a given RGB.
 340  * Nearest is defined by minimizing the sum of the squares.
 341  */
 342 static INT X11DRV_DIB_GetNearestIndex(RGBQUAD *colormap, int numColors, BYTE r, BYTE g, BYTE b)
 343 {
 344     INT i, best = -1, diff, bestdiff = -1;
 345     RGBQUAD *color;
 346
 347     for(color = colormap, i = 0; i < numColors; color++, i++) {
 348         diff = (r - color->rgbRed) * (r - color->rgbRed) +
 349                (g - color->rgbGreen) * (g - color->rgbGreen) +
 350                (b - color->rgbBlue) * (b - color->rgbBlue);
 351         if(diff == 0)
 352             return i;
 353         if(best == -1 || diff < bestdiff) {
 354             best = i;
 355             bestdiff = diff;
 356         }
 357     }
 358     return best;
 359 }
 360 /*********************************************************************
 361  *         X11DRV_DIB_MaskToShift
 362  *
 363  * Helper for X11DRV_DIB_GetDIBits.
 364  * Returns the by how many bits to shift a given color so that it is
 365  * in the proper position.
 366  */
 367 INT X11DRV_DIB_MaskToShift(DWORD mask)
 368 {
 369     int shift;
 370
 371     if (mask==0)
 372         return 0;
 373
 374     shift=0;
 375     while ((mask&1)==0) {
 376         mask>>=1;
 377         shift++;
 378     }
 379     return shift;
 380 }
 381
 382 /***********************************************************************
 383  *           X11DRV_DIB_CheckMask
 384  *
 385  * Check RGB mask if it is either 0 or matches visual's mask.
 386  */
 387 static inline int X11DRV_DIB_CheckMask(int red_mask, int green_mask, int blue_mask)
 388 {
 389     return ( red_mask == 0 && green_mask == 0 && blue_mask == 0 ) ||
 390            ( red_mask == visual->red_mask && green_mask == visual->green_mask &&
 391              blue_mask == visual->blue_mask );
 392 }
 393
 394 /***********************************************************************
 395  *           X11DRV_DIB_SetImageBits_1
 396  *
 397  * SetDIBits for a 1-bit deep DIB.
 398  */
 399 static void X11DRV_DIB_SetImageBits_1( int lines, const BYTE *srcbits,
 400                                 DWORD srcwidth, DWORD dstwidth, int left,
 401                                 int *colors, XImage *bmpImage, int linebytes)
 402 {
 403     int h, width;
 404     const BYTE* srcbyte;
 405     BYTE srcval, extra;
 406     DWORD i, x;
 407
 408     if (lines < 0 ) {
 409         lines = -lines;
 410         srcbits = srcbits + linebytes * (lines - 1);
 411         linebytes = -linebytes;
 412     }
 413
 414     if ((extra = (left & 7)) != 0) {
 415         left &= ~7;
 416         dstwidth += extra;
 417     }
 418     srcbits += left >> 3;
 419     width = min(srcwidth, dstwidth);
 420
 421     /* ==== pal 1 dib -> any bmp format ==== */
 422     for (h = lines-1; h >=0; h--) {
 423         srcbyte=srcbits;
 424         for (i = width/8, x = left; i > 0; i--) {
 425             srcval=*srcbyte++;
 426             XPutPixel( bmpImage, x++, h, colors[ srcval >> 7] );
 427             XPutPixel( bmpImage, x++, h, colors[(srcval >> 6) & 1] );
 428             XPutPixel( bmpImage, x++, h, colors[(srcval >> 5) & 1] );
 429             XPutPixel( bmpImage, x++, h, colors[(srcval >> 4) & 1] );
 430             XPutPixel( bmpImage, x++, h, colors[(srcval >> 3) & 1] );
 431             XPutPixel( bmpImage, x++, h, colors[(srcval >> 2) & 1] );
 432             XPutPixel( bmpImage, x++, h, colors[(srcval >> 1) & 1] );
 433             XPutPixel( bmpImage, x++, h, colors[ srcval       & 1] );
 434         }
 435         if (width % 8){
 436             srcval=*srcbyte;
 437             switch (width & 7)
 438             {
 439             case 7: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
 440                 /* fall through */
 441             case 6: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
 442                 /* fall through */
 443             case 5: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
 444                 /* fall through */
 445             case 4: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
 446                 /* fall through */
 447             case 3: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
 448                 /* fall through */
 449             case 2: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
 450                 /* fall through */
 451             case 1: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]);
 452             }
 453         }
 454         srcbits += linebytes;
 455     }
 456 }
 457
 458 /***********************************************************************
 459  *           X11DRV_DIB_GetImageBits_1
 460  *
 461  * GetDIBits for a 1-bit deep DIB.
 462  */
 463 static void X11DRV_DIB_GetImageBits_1( int lines, BYTE *dstbits,
 464                                        DWORD dstwidth, DWORD srcwidth,
 465                                        RGBQUAD *colors, PALETTEENTRY *srccolors,
 466                                        XImage *bmpImage, int linebytes )
 467 {
 468     DWORD x;
 469     int h, width = min(dstwidth, srcwidth);
 470
 471     if (lines < 0 ) {
 472         lines = -lines;
 473         dstbits = dstbits + linebytes * (lines - 1);
 474         linebytes = -linebytes;
 475     }
 476
 477     switch (bmpImage->depth)
 478     {
 479     case 1:
 480     case 4:
 481         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
 482             && srccolors) {
 483             /* ==== pal 1 or 4 bmp -> pal 1 dib ==== */
 484             BYTE* dstbyte;
 485
 486             for (h=lines-1; h>=0; h--) {
 487                 BYTE dstval;
 488                 dstbyte=dstbits;
 489                 dstval=0;
 490                 for (x=0; x<width; x++) {
 491                     PALETTEENTRY srcval;
 492                     srcval=srccolors[XGetPixel(bmpImage, x, h)];
 493                     dstval|=(X11DRV_DIB_GetNearestIndex
 494                              (colors, 2,
 495                               srcval.peRed,
 496                               srcval.peGreen,
 497                               srcval.peBlue) << (7 - (x & 7)));
 498                     if ((x&7)==7) {
 499                         *dstbyte++=dstval;
 500                         dstval=0;
 501                     }
 502                 }
 503                 if ((width&7)!=0) {
 504                     *dstbyte++=dstval;
 505                 }
 506                 /* pad with 0 to DWORD alignment */
 507                 for (x = (x+7)&~7; x < ((width + 31) & ~31); x+=8)
 508                     *dstbyte++ = 0;
 509                 dstbits += linebytes;
 510             }
 511         } else {
 512             goto notsupported;
 513         }
 514         break;
 515
 516     case 8:
 517         if (X11DRV_DIB_CheckMask(bmpImage->red_mask, bmpImage->green_mask, bmpImage->blue_mask)
 518             && srccolors) {
 519             /* ==== pal 8 bmp -> pal 1 dib ==== */
 520             const void* srcbits;
 521             const BYTE* srcpixel;
 522             BYTE* dstbyte;
 523
 524             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
 525
 526             for (h=0; h<lines; h++) {
 527                 BYTE dstval;
 528                 srcpixel=srcbits;
 529                 dstbyte=dstbits;
 530                 dstval=0;
 531                 for (x=0; x<width; x++) {
 532                     PALETTEENTRY srcval;
 533                     srcval=srccolors[*srcpixel++];
 534                     dstval|=(X11DRV_DIB_GetNearestIndex
 535                              (colors, 2,
 536                               srcval.peRed,
 537                               srcval.peGreen,
 538                               srcval.peBlue) << (7-(x&7)) );
 539                     if ((x&7)==7) {
 540                         *dstbyte++=dstval;
 541                         dstval=0;
 542                     }
 543                 }
 544                 if ((width&7)!=0) {
 545                     *dstbyte=dstval;
 546                 }
 547                 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
 548                 dstbits += linebytes;
 549             }
 550         } else {
 551             goto notsupported;
 552         }
 553         break;
 554
 555     case 15:
 556     case 16:
 557         {
 558             const void* srcbits;
 559             const WORD* srcpixel;
 560             BYTE* dstbyte;
 561
 562             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
 563
 564             if (bmpImage->green_mask==0x03e0) {
 565                 if (bmpImage->red_mask==0x7c00) {
 566                     /* ==== rgb 555 bmp -> pal 1 dib ==== */
 567                     for (h=0; h<lines; h++) {
 568                         BYTE dstval;
 569                         srcpixel=srcbits;
 570                         dstbyte=dstbits;
 571                         dstval=0;
 572                         for (x=0; x<width; x++) {
 573                             WORD srcval;
 574                             srcval=*srcpixel++;
 575                             dstval|=(X11DRV_DIB_GetNearestIndex
 576                                      (colors, 2,
 577                                       ((srcval >>  7) & 0xf8) | /* r */
 578                                       ((srcval >> 12) & 0x07),
 579                                       ((srcval >>  2) & 0xf8) | /* g */
 580                                       ((srcval >>  7) & 0x07),
 581                                       ((srcval <<  3) & 0xf8) | /* b */
 582                                       ((srcval >>  2) & 0x07) ) << (7-(x&7)) );
 583                             if ((x&7)==7) {
 584                                 *dstbyte++=dstval;
 585                                 dstval=0;
 586                             }
 587                         }
 588                         if ((width&7)!=0) {
 589                             *dstbyte=dstval;
 590                         }
 591                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
 592                         dstbits += linebytes;
 593                     }
 594                 } else if (bmpImage->blue_mask==0x7c00) {
 595                     /* ==== bgr 555 bmp -> pal 1 dib ==== */
 596                     for (h=0; h<lines; h++) {
 597                         WORD dstval;
 598                         srcpixel=srcbits;
 599                         dstbyte=dstbits;
 600                         dstval=0;
 601                         for (x=0; x<width; x++) {
 602                             BYTE srcval;
 603                             srcval=*srcpixel++;
 604                             dstval|=(X11DRV_DIB_GetNearestIndex
 605                                      (colors, 2,
 606                                       ((srcval <<  3) & 0xf8) | /* r */
 607                                       ((srcval >>  2) & 0x07),
 608                                       ((srcval >>  2) & 0xf8) | /* g */
 609                                       ((srcval >>  7) & 0x07),
 610                                       ((srcval >>  7) & 0xf8) | /* b */
 611                                       ((srcval >> 12) & 0x07) ) << (7-(x&7)) );
 612                             if ((x&7)==7) {
 613                                 *dstbyte++=dstval;
 614                                 dstval=0;
 615                             }
 616                         }
 617                         if ((width&7)!=0) {
 618                             *dstbyte=dstval;
 619                         }
 620                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
 621                         dstbits += linebytes;
 622                     }
 623                 } else {
 624                     goto notsupported;
 625                 }
 626             } else if (bmpImage->green_mask==0x07e0) {
 627                 if (bmpImage->red_mask==0xf800) {
 628                     /* ==== rgb 565 bmp -> pal 1 dib ==== */
 629                     for (h=0; h<lines; h++) {
 630                         BYTE dstval;
 631                         srcpixel=srcbits;
 632                         dstbyte=dstbits;
 633                         dstval=0;
 634                         for (x=0; x<width; x++) {
 635                             WORD srcval;
 636                             srcval=*srcpixel++;
 637                             dstval|=(X11DRV_DIB_GetNearestIndex
 638                                      (colors, 2,
 639                                       ((srcval >>  8) & 0xf8) | /* r */
 640                                       ((srcval >> 13) & 0x07),
 641                                       ((srcval >>  3) & 0xfc) | /* g */
 642                                       ((srcval >>  9) & 0x03),
 643                                       ((srcval <<  3) & 0xf8) | /* b */
 644                                       ((srcval >>  2) & 0x07) ) << (7-(x&7)) );
 645                             if ((x&7)==7) {
 646                                 *dstbyte++=dstval;
 647                                 dstval=0;
 648                             }
 649                         }
 650                         if ((width&7)!=0) {
 651                             *dstbyte=dstval;
 652                         }
 653                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
 654                         dstbits += linebytes;
 655                     }
 656                 } else if (bmpImage->blue_mask==0xf800) {
 657                     /* ==== bgr 565 bmp -> pal 1 dib ==== */
 658                     for (h=0; h<lines; h++) {
 659                         BYTE dstval;
 660                         srcpixel=srcbits;
 661                         dstbyte=dstbits;
 662                         dstval=0;
 663                         for (x=0; x<width; x++) {
 664                             WORD srcval;
 665                             srcval=*srcpixel++;
 666                             dstval|=(X11DRV_DIB_GetNearestIndex
 667                                      (colors, 2,
 668                                       ((srcval <<  3) & 0xf8) | /* r */
 669                                       ((srcval >>  2) & 0x07),
 670                                       ((srcval >>  3) & 0xfc) | /* g */
 671                                       ((srcval >>  9) & 0x03),
 672                                       ((srcval >>  8) & 0xf8) | /* b */
 673                                       ((srcval >> 13) & 0x07) ) << (7-(x&7)) );
 674                             if ((x&7)==7) {
 675                                 *dstbyte++=dstval;
 676                                 dstval=0;
 677                             }
 678                         }
 679                         if ((width&7)!=0) {
 680                             *dstbyte=dstval;
 681                         }
 682                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
 683                         dstbits += linebytes;
 684                     }
 685                 } else {
 686                     goto notsupported;
 687                 }
 688             } else {
 689                 goto notsupported;
 690             }
 691         }
 692         break;
 693
 694     case 24:
 695     case 32:
 696         {
 697             const void* srcbits;
 698             const BYTE *srcbyte;
 699             BYTE* dstbyte;
 700             int bytes_per_pixel;
 701
 702             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
 703             bytes_per_pixel=(bmpImage->bits_per_pixel==24?3:4);
 704
 705             if (bmpImage->green_mask!=0x00ff00 ||
 706                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
 707                 goto notsupported;
 708             } else if (bmpImage->blue_mask==0xff) {
 709                 /* ==== rgb 888 or 0888 bmp -> pal 1 dib ==== */
 710                 for (h=0; h<lines; h++) {
 711                     BYTE dstval;
 712                     srcbyte=srcbits;
 713                     dstbyte=dstbits;
 714                     dstval=0;
 715                     for (x=0; x<width; x++) {
 716                         dstval|=(X11DRV_DIB_GetNearestIndex
 717                                  (colors, 2,
 718                                   srcbyte[2],
 719                                   srcbyte[1],
 720                                   srcbyte[0]) << (7-(x&7)) );
 721                         srcbyte+=bytes_per_pixel;
 722                         if ((x&7)==7) {
 723                             *dstbyte++=dstval;
 724                             dstval=0;
 725                         }
 726                     }
 727                     if ((width&7)!=0) {
 728                         *dstbyte=dstval;
 729                     }
 730                     srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
 731                     dstbits += linebytes;
 732                 }
 733             } else {
 734                 /* ==== bgr 888 or 0888 bmp -> pal 1 dib ==== */
 735                 for (h=0; h<lines; h++) {
 736                     BYTE dstval;
 737                     srcbyte=srcbits;
 738                     dstbyte=dstbits;
 739                     dstval=0;
 740                     for (x=0; x<width; x++) {
 741                         dstval|=(X11DRV_DIB_GetNearestIndex
 742                                  (colors, 2,
 743                                   srcbyte[0],
 744                                   srcbyte[1],
 745                                   srcbyte[2]) << (7-(x&7)) );
 746                         srcbyte+=bytes_per_pixel;
 747                         if ((x&7)==7) {
 748                             *dstbyte++=dstval;
 749                             dstval=0;
 750                         }
 751                     }
 752                     if ((width&7)!=0) {
 753                         *dstbyte=dstval;
 754                     }
 755                     srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
 756                     dstbits += linebytes;
 757                 }
 758             }
 759         }
 760         break;
 761
 762     default:
 763     notsupported:
 764         {
 765             BYTE* dstbyte;
 766             BYTE neg = 0;
 767             unsigned long white = (1 << bmpImage->bits_per_pixel) - 1;
 768
 769             /* ==== any bmp format -> pal 1 dib ==== */
 770             if ((unsigned)colors[0].rgbRed+colors[0].rgbGreen+colors[0].rgbBlue >=
 771                 (unsigned)colors[1].rgbRed+colors[1].rgbGreen+colors[1].rgbBlue )
 772                 neg = 1;
 773
 774             WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 1 bit DIB, "
 775                  "%s color mapping\n",
 776                   bmpImage->bits_per_pixel, bmpImage->red_mask,
 777                   bmpImage->green_mask, bmpImage->blue_mask,
 778                   neg?"negative":"direct" );
 779
 780             for (h=lines-1; h>=0; h--) {
 781                 BYTE dstval;
 782                 dstbyte=dstbits;
 783                 dstval=0;
 784                 for (x=0; x<width; x++) {
 785                     dstval|=((XGetPixel( bmpImage, x, h) >= white) ^ neg) << (7 - (x&7));
 786                     if ((x&7)==7) {
 787                         *dstbyte++=dstval;
 788                         dstval=0;
 789                     }
 790                 }
 791                 if ((width&7)!=0) {
 792                     *dstbyte=dstval;
 793                 }
 794                 dstbits += linebytes;
 795             }
 796         }
 797         break;
 798     }
 799 }
 800
 801 /***********************************************************************
 802  *           X11DRV_DIB_SetImageBits_4
 803  *
 804  * SetDIBits for a 4-bit deep DIB.
 805  */
 806 static void X11DRV_DIB_SetImageBits_4( int lines, const BYTE *srcbits,
 807                                 DWORD srcwidth, DWORD dstwidth, int left,
 808                                 int *colors, XImage *bmpImage, int linebytes)
 809 {
 810     int h, width;
 811     const BYTE* srcbyte;
 812     DWORD i, x;
 813
 814     if (lines < 0 ) {
 815         lines = -lines;
 816         srcbits = srcbits + linebytes * (lines - 1);
 817         linebytes = -linebytes;
 818     }
 819
 820     if (left & 1) {
 821         left--;
 822         dstwidth++;
 823     }
 824     srcbits += left >> 1;
 825     width = min(srcwidth, dstwidth);
 826
 827     /* ==== pal 4 dib -> any bmp format ==== */
 828     for (h = lines-1; h >= 0; h--) {
 829         srcbyte=srcbits;
 830         for (i = width/2, x = left; i > 0; i--) {
 831             BYTE srcval=*srcbyte++;
 832             XPutPixel( bmpImage, x++, h, colors[srcval >> 4] );
 833             XPutPixel( bmpImage, x++, h, colors[srcval & 0x0f] );
 834         }
 835         if (width & 1)
 836             XPutPixel( bmpImage, x, h, colors[*srcbyte >> 4] );
 837         srcbits += linebytes;
 838     }
 839 }
 840
 841
 842
 843 /***********************************************************************
 844  *           X11DRV_DIB_GetImageBits_4
 845  *
 846  * GetDIBits for a 4-bit deep DIB.
 847  */
 848 static void X11DRV_DIB_GetImageBits_4( int lines, BYTE *dstbits,
 849                                        DWORD srcwidth, DWORD dstwidth,
 850                                        RGBQUAD *colors, PALETTEENTRY *srccolors,
 851                                        XImage *bmpImage, int linebytes )
 852 {
 853     DWORD x;
 854     int h, width = min(srcwidth, dstwidth);
 855
 856     if (lines < 0 )
 857     {
 858        lines = -lines;
 859        dstbits = dstbits + ( linebytes * (lines-1) );
 860        linebytes = -linebytes;
 861     }
 862
 863     switch (bmpImage->depth) {
 864     case 1:
 865     case 4:
 866         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
 867             && srccolors) {
 868             /* ==== pal 1 or 4 bmp -> pal 4 dib ==== */
 869             BYTE* dstbyte;
 870
 871             for (h = lines-1; h >= 0; h--) {
 872                 BYTE dstval;
 873                 dstbyte=dstbits;
 874                 dstval=0;
 875                 for (x = 0; x < width; x++) {
 876                     PALETTEENTRY srcval;
 877                     srcval=srccolors[XGetPixel(bmpImage, x, h)];
 878                     dstval|=(X11DRV_DIB_GetNearestIndex
 879                              (colors, 16,
 880                               srcval.peRed,
 881                               srcval.peGreen,
 882                               srcval.peBlue) << (4-((x&1)<<2)));
 883                     if ((x&1)==1) {
 884                         *dstbyte++=dstval;
 885                         dstval=0;
 886                     }
 887                 }
 888                 if ((width&1)!=0) {
 889                     *dstbyte=dstval;
 890                 }
 891                 dstbits += linebytes;
 892             }
 893         } else {
 894             goto notsupported;
 895         }
 896         break;
 897
 898     case 8:
 899         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
 900             && srccolors) {
 901             /* ==== pal 8 bmp -> pal 4 dib ==== */
 902             const void* srcbits;
 903             const BYTE *srcpixel;
 904             BYTE* dstbyte;
 905
 906             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
 907             for (h=0; h<lines; h++) {
 908                 BYTE dstval;
 909                 srcpixel=srcbits;
 910                 dstbyte=dstbits;
 911                 dstval=0;
 912                 for (x=0; x<width; x++) {
 913                     PALETTEENTRY srcval;
 914                     srcval = srccolors[*srcpixel++];
 915                     dstval|=(X11DRV_DIB_GetNearestIndex
 916                              (colors, 16,
 917                               srcval.peRed,
 918                               srcval.peGreen,
 919                               srcval.peBlue) << (4*(1-(x&1))) );
 920                     if ((x&1)==1) {
 921                         *dstbyte++=dstval;
 922                         dstval=0;
 923                     }
 924                 }
 925                 if ((width&1)!=0) {
 926                     *dstbyte=dstval;
 927                 }
 928                 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
 929                 dstbits += linebytes;
 930             }
 931         } else {
 932             goto notsupported;
 933         }
 934         break;
 935
 936     case 15:
 937     case 16:
 938         {
 939             const void* srcbits;
 940             const WORD* srcpixel;
 941             BYTE* dstbyte;
 942
 943             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
 944
 945             if (bmpImage->green_mask==0x03e0) {
 946                 if (bmpImage->red_mask==0x7c00) {
 947                     /* ==== rgb 555 bmp -> pal 4 dib ==== */
 948                     for (h=0; h<lines; h++) {
 949                         BYTE dstval;
 950                         srcpixel=srcbits;
 951                         dstbyte=dstbits;
 952                         dstval=0;
 953                         for (x=0; x<width; x++) {
 954                             WORD srcval;
 955                             srcval=*srcpixel++;
 956                             dstval|=(X11DRV_DIB_GetNearestIndex
 957                                      (colors, 16,
 958                                       ((srcval >>  7) & 0xf8) | /* r */
 959                                       ((srcval >> 12) & 0x07),
 960                                       ((srcval >>  2) & 0xf8) | /* g */
 961                                       ((srcval >>  7) & 0x07),
 962                                       ((srcval <<  3) & 0xf8) | /* b */
 963                                       ((srcval >>  2) & 0x07) ) << ((1-(x&1))<<2) );
 964                             if ((x&1)==1) {
 965                                 *dstbyte++=dstval;
 966                                 dstval=0;
 967                             }
 968                         }
 969                         if ((width&1)!=0) {
 970                             *dstbyte=dstval;
 971                         }
 972                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
 973                         dstbits += linebytes;
 974                     }
 975                 } else if (bmpImage->blue_mask==0x7c00) {
 976                     /* ==== bgr 555 bmp -> pal 4 dib ==== */
 977                     for (h=0; h<lines; h++) {
 978                         WORD dstval;
 979                         srcpixel=srcbits;
 980                         dstbyte=dstbits;
 981                         dstval=0;
 982                         for (x=0; x<width; x++) {
 983                             WORD srcval;
 984                             srcval=*srcpixel++;
 985                             dstval|=(X11DRV_DIB_GetNearestIndex
 986                                      (colors, 16,
 987                                       ((srcval <<  3) & 0xf8) | /* r */
 988                                       ((srcval >>  2) & 0x07),
 989                                       ((srcval >>  2) & 0xf8) | /* g */
 990                                       ((srcval >>  7) & 0x07),
 991                                       ((srcval >>  7) & 0xf8) | /* b */
 992                                       ((srcval >> 12) & 0x07) ) << ((1-(x&1))<<2) );
 993                             if ((x&1)==1) {
 994                                 *dstbyte++=dstval;
 995                                 dstval=0;
 996                             }
 997                         }
 998                         if ((width&1)!=0) {
 999                             *dstbyte=dstval;
1000                         }
1001                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1002                         dstbits += linebytes;
1003                     }
1004                 } else {
1005                     goto notsupported;
1006                 }
1007             } else if (bmpImage->green_mask==0x07e0) {
1008                 if (bmpImage->red_mask==0xf800) {
1009                     /* ==== rgb 565 bmp -> pal 4 dib ==== */
1010                     for (h=0; h<lines; h++) {
1011                         BYTE dstval;
1012                         srcpixel=srcbits;
1013                         dstbyte=dstbits;
1014                         dstval=0;
1015                         for (x=0; x<width; x++) {
1016                             WORD srcval;
1017                             srcval=*srcpixel++;
1018                             dstval|=(X11DRV_DIB_GetNearestIndex
1019                                      (colors, 16,
1020                                       ((srcval >>  8) & 0xf8) | /* r */
1021                                       ((srcval >> 13) & 0x07),
1022                                       ((srcval >>  3) & 0xfc) | /* g */
1023                                       ((srcval >>  9) & 0x03),
1024                                       ((srcval <<  3) & 0xf8) | /* b */
1025                                       ((srcval >>  2) & 0x07) ) << ((1-(x&1))<<2) );
1026                             if ((x&1)==1) {
1027                                 *dstbyte++=dstval;
1028                                 dstval=0;
1029                             }
1030                         }
1031                         if ((width&1)!=0) {
1032                             *dstbyte=dstval;
1033                         }
1034                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1035                         dstbits += linebytes;
1036                     }
1037                 } else if (bmpImage->blue_mask==0xf800) {
1038                     /* ==== bgr 565 bmp -> pal 4 dib ==== */
1039                     for (h=0; h<lines; h++) {
1040                         WORD dstval;
1041                         srcpixel=srcbits;
1042                         dstbyte=dstbits;
1043                         dstval=0;
1044                         for (x=0; x<width; x++) {
1045                             WORD srcval;
1046                             srcval=*srcpixel++;
1047                             dstval|=(X11DRV_DIB_GetNearestIndex
1048                                      (colors, 16,
1049                                       ((srcval <<  3) & 0xf8) | /* r */
1050                                       ((srcval >>  2) & 0x07),
1051                                       ((srcval >>  3) & 0xfc) | /* g */
1052                                       ((srcval >>  9) & 0x03),
1053                                       ((srcval >>  8) & 0xf8) | /* b */
1054                                       ((srcval >> 13) & 0x07) ) << ((1-(x&1))<<2) );
1055                             if ((x&1)==1) {
1056                                 *dstbyte++=dstval;
1057                                 dstval=0;
1058                             }
1059                         }
1060                         if ((width&1)!=0) {
1061                             *dstbyte=dstval;
1062                         }
1063                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1064                         dstbits += linebytes;
1065                     }
1066                 } else {
1067                     goto notsupported;
1068                 }
1069             } else {
1070                 goto notsupported;
1071             }
1072         }
1073         break;
1074
1075     case 24:
1076         if (bmpImage->bits_per_pixel==24) {
1077             const void* srcbits;
1078             const BYTE *srcbyte;
1079             BYTE* dstbyte;
1080
1081             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1082
1083             if (bmpImage->green_mask!=0x00ff00 ||
1084                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
1085                 goto notsupported;
1086             } else if (bmpImage->blue_mask==0xff) {
1087                 /* ==== rgb 888 bmp -> pal 4 dib ==== */
1088                 for (h=0; h<lines; h++) {
1089                     srcbyte=srcbits;
1090                     dstbyte=dstbits;
1091                     for (x=0; x<width/2; x++) {
1092                         /* Do 2 pixels at a time */
1093                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
1094                                     (colors, 16,
1095                                      srcbyte[2],
1096                                      srcbyte[1],
1097                                      srcbyte[0]) << 4) |
1098                                     X11DRV_DIB_GetNearestIndex
1099                                     (colors, 16,
1100                                      srcbyte[5],
1101                                      srcbyte[4],
1102                                      srcbyte[3]);
1103                         srcbyte+=6;
1104                     }
1105                     if (width&1) {
1106                         /* And then the odd pixel */
1107                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
1108                                     (colors, 16,
1109                                      srcbyte[2],
1110                                      srcbyte[1],
1111                                      srcbyte[0]) << 4);
1112                     }
1113                     srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1114                     dstbits += linebytes;
1115                 }
1116             } else {
1117                 /* ==== bgr 888 bmp -> pal 4 dib ==== */
1118                 for (h=0; h<lines; h++) {
1119                     srcbyte=srcbits;
1120                     dstbyte=dstbits;
1121                     for (x=0; x<width/2; x++) {
1122                         /* Do 2 pixels at a time */
1123                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
1124                                     (colors, 16,
1125                                      srcbyte[0],
1126                                      srcbyte[1],
1127                                      srcbyte[2]) << 4) |
1128                                     X11DRV_DIB_GetNearestIndex
1129                                     (colors, 16,
1130                                      srcbyte[3],
1131                                      srcbyte[4],
1132                                      srcbyte[5]);
1133                         srcbyte+=6;
1134                     }
1135                     if (width&1) {
1136                         /* And then the odd pixel */
1137                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
1138                                     (colors, 16,
1139                                      srcbyte[0],
1140                                      srcbyte[1],
1141                                      srcbyte[2]) << 4);
1142                     }
1143                     srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1144                     dstbits += linebytes;
1145                 }
1146             }
1147             break;
1148         }
1149         /* Fall through */
1150
1151     case 32:
1152         {
1153             const void* srcbits;
1154             const BYTE *srcbyte;
1155             BYTE* dstbyte;
1156
1157             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1158
1159             if (bmpImage->green_mask!=0x00ff00 ||
1160                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
1161                 goto notsupported;
1162             } else if (bmpImage->blue_mask==0xff) {
1163                 /* ==== rgb 0888 bmp -> pal 4 dib ==== */
1164                 for (h=0; h<lines; h++) {
1165                     srcbyte=srcbits;
1166                     dstbyte=dstbits;
1167                     for (x=0; x<width/2; x++) {
1168                         /* Do 2 pixels at a time */
1169                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
1170                                     (colors, 16,
1171                                      srcbyte[2],
1172                                      srcbyte[1],
1173                                      srcbyte[0]) << 4) |
1174                                     X11DRV_DIB_GetNearestIndex
1175                                     (colors, 16,
1176                                      srcbyte[6],
1177                                      srcbyte[5],
1178                                      srcbyte[4]);
1179                         srcbyte+=8;
1180                     }
1181                     if (width&1) {
1182                         /* And then the odd pixel */
1183                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
1184                                     (colors, 16,
1185                                      srcbyte[2],
1186                                      srcbyte[1],
1187                                      srcbyte[0]) << 4);
1188                     }
1189                     srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1190                     dstbits += linebytes;
1191                 }
1192             } else {
1193                 /* ==== bgr 0888 bmp -> pal 4 dib ==== */
1194                 for (h=0; h<lines; h++) {
1195                     srcbyte=srcbits;
1196                     dstbyte=dstbits;
1197                     for (x=0; x<width/2; x++) {
1198                         /* Do 2 pixels at a time */
1199                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
1200                                     (colors, 16,
1201                                      srcbyte[0],
1202                                      srcbyte[1],
1203                                      srcbyte[2]) << 4) |
1204                                     X11DRV_DIB_GetNearestIndex
1205                                     (colors, 16,
1206                                      srcbyte[4],
1207                                      srcbyte[5],
1208                                      srcbyte[6]);
1209                         srcbyte+=8;
1210                     }
1211                     if (width&1) {
1212                         /* And then the odd pixel */
1213                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
1214                                     (colors, 16,
1215                                      srcbyte[0],
1216                                      srcbyte[1],
1217                                      srcbyte[2]) << 4);
1218                     }
1219                     srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1220                     dstbits += linebytes;
1221                 }
1222             }
1223         }
1224         break;
1225
1226     default:
1227     notsupported:
1228         {
1229             BYTE* dstbyte;
1230
1231             /* ==== any bmp format -> pal 4 dib ==== */
1232             WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 4 bit DIB\n",
1233                   bmpImage->bits_per_pixel, bmpImage->red_mask,
1234                   bmpImage->green_mask, bmpImage->blue_mask );
1235             for (h=lines-1; h>=0; h--) {
1236                 dstbyte=dstbits;
1237                 for (x=0; x<(width & ~1); x+=2) {
1238                     *dstbyte++=(X11DRV_DIB_MapColor((int*)colors, 16, XGetPixel(bmpImage, x, h), 0) << 4) |
1239                         X11DRV_DIB_MapColor((int*)colors, 16, XGetPixel(bmpImage, x+1, h), 0);
1240                 }
1241                 if (width & 1) {
1242                     *dstbyte=(X11DRV_DIB_MapColor((int *)colors, 16, XGetPixel(bmpImage, x, h), 0) << 4);
1243                 }
1244                 dstbits += linebytes;
1245             }
1246         }
1247         break;
1248     }
1249 }
1250
1251 /***********************************************************************
1252  *           X11DRV_DIB_SetImageBits_8
1253  *
1254  * SetDIBits for an 8-bit deep DIB.
1255  */
1256 static void X11DRV_DIB_SetImageBits_8( int lines, const BYTE *srcbits,
1257                                 DWORD srcwidth, DWORD dstwidth, int left,
1258                                 const int *colors, XImage *bmpImage,
1259                                 int linebytes )
1260 {
1261     DWORD x;
1262     int h, width = min(srcwidth, dstwidth);
1263     const BYTE* srcbyte;
1264     BYTE* dstbits;
1265
1266     if (lines < 0 )
1267     {
1268         lines = -lines;
1269         srcbits = srcbits + linebytes * (lines-1);
1270         linebytes = -linebytes;
1271     }
1272     srcbits += left;
1273     srcbyte = srcbits;
1274
1275     switch (bmpImage->depth) {
1276     case 15:
1277     case 16:
1278         /* Some X servers might have 32 bit/ 16bit deep pixel */
1279         if (lines && width && (bmpImage->bits_per_pixel == 16) &&
1280             (ImageByteOrder(gdi_display)==LSBFirst) )
1281         {
1282             /* ==== pal 8 dib -> rgb or bgr 555 or 565 bmp ==== */
1283             dstbits=(BYTE*)bmpImage->data+left*2+(lines-1)*bmpImage->bytes_per_line;
1284             for (h = lines ; h--; ) {
1285                 DWORD* dstpixel=(DWORD*)dstbits;
1286                 for (x=0; x<width/2; x++) {
1287                     /* Do 2 pixels at a time */
1288                     *dstpixel++=(colors[srcbyte[1]] << 16) | colors[srcbyte[0]];
1289                     srcbyte+=2;
1290                 }
1291                 if (width&1) {
1292                     /* And then the odd pixel */
1293                     *((WORD*)dstpixel)=colors[srcbyte[0]];
1294                 }
1295                 srcbyte = (srcbits += linebytes);
1296                 dstbits -= bmpImage->bytes_per_line;
1297             }
1298             return;
1299         }
1300         break;
1301     case 24:
1302     case 32:
1303         if (lines && width && (bmpImage->bits_per_pixel == 32) &&
1304             (ImageByteOrder(gdi_display)==LSBFirst) )
1305         {
1306             dstbits=(BYTE*)bmpImage->data+left*4+(lines-1)*bmpImage->bytes_per_line;
1307             /* ==== pal 8 dib -> rgb or bgr 0888 bmp ==== */
1308             for (h = lines ; h--; ) {
1309                 DWORD* dstpixel=(DWORD*)dstbits;
1310                 for (x=0; x<width; x++) {
1311                     *dstpixel++=colors[*srcbyte++];
1312                 }
1313                 srcbyte = (srcbits += linebytes);
1314                 dstbits -= bmpImage->bytes_per_line;
1315             }
1316             return;
1317         }
1318         break;
1319     default:
1320         break; /* use slow generic case below */
1321     }
1322
1323     /* ==== pal 8 dib -> any bmp format ==== */
1324     for (h=lines-1; h>=0; h--) {
1325         for (x=left; x<width+left; x++) {
1326             XPutPixel(bmpImage, x, h, colors[*srcbyte++]);
1327         }
1328         srcbyte = (srcbits += linebytes);
1329     }
1330 }
1331
1332 /***********************************************************************
1333  *           X11DRV_DIB_GetImageBits_8
1334  *
1335  * GetDIBits for an 8-bit deep DIB.
1336  */
1337 static void X11DRV_DIB_GetImageBits_8( int lines, BYTE *dstbits,
1338                                        DWORD srcwidth, DWORD dstwidth,
1339                                        RGBQUAD *colors, PALETTEENTRY *srccolors,
1340                                        XImage *bmpImage, int linebytes )
1341 {
1342     DWORD x;
1343     int h, width = min(srcwidth, dstwidth);
1344     BYTE* dstbyte;
1345
1346     if (lines < 0 )
1347     {
1348        lines = -lines;
1349        dstbits = dstbits + ( linebytes * (lines-1) );
1350        linebytes = -linebytes;
1351     }
1352
1353     /*
1354      * Hack for now
1355      * This condition is true when GetImageBits has been called by
1356      * UpdateDIBSection. For now, GetNearestIndex is too slow to support
1357      * 256 colormaps, so we'll just use it for GetDIBits calls.
1358      * (In some cases, in an updateDIBSection, the returned colors are bad too)
1359      */
1360     if (!srccolors) goto updatesection;
1361
1362     switch (bmpImage->depth) {
1363     case 1:
1364     case 4:
1365         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
1366             && srccolors) {
1367
1368             /* ==== pal 1 bmp -> pal 8 dib ==== */
1369             /* ==== pal 4 bmp -> pal 8 dib ==== */
1370             for (h=lines-1; h>=0; h--) {
1371                 dstbyte=dstbits;
1372                 for (x=0; x<width; x++) {
1373                     PALETTEENTRY srcval;
1374                     srcval=srccolors[XGetPixel(bmpImage, x, h)];
1375                     *dstbyte++=X11DRV_DIB_GetNearestIndex(colors, 256,
1376                                                           srcval.peRed,
1377                                                           srcval.peGreen,
1378                                                           srcval.peBlue);
1379                 }
1380                 dstbits += linebytes;
1381             }
1382         } else {
1383             goto notsupported;
1384         }
1385         break;
1386
1387     case 8:
1388        if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
1389            && srccolors) {
1390             /* ==== pal 8 bmp -> pal 8 dib ==== */
1391            const void* srcbits;
1392            const BYTE* srcpixel;
1393
1394            srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1395            for (h=0; h<lines; h++) {
1396                srcpixel=srcbits;
1397                dstbyte=dstbits;
1398                for (x = 0; x < width; x++) {
1399                    PALETTEENTRY srcval;
1400                    srcval=srccolors[*srcpixel++];
1401                    *dstbyte++=X11DRV_DIB_GetNearestIndex(colors, 256,
1402                                                          srcval.peRed,
1403                                                          srcval.peGreen,
1404                                                          srcval.peBlue);
1405                }
1406                srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1407                dstbits += linebytes;
1408            }
1409        } else {
1410            goto notsupported;
1411        }
1412        break;
1413
1414     case 15:
1415     case 16:
1416         {
1417             const void* srcbits;
1418             const WORD* srcpixel;
1419             BYTE* dstbyte;
1420
1421             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1422
1423             if (bmpImage->green_mask==0x03e0) {
1424                 if (bmpImage->red_mask==0x7c00) {
1425                     /* ==== rgb 555 bmp -> pal 8 dib ==== */
1426                     for (h=0; h<lines; h++) {
1427                         srcpixel=srcbits;
1428                         dstbyte=dstbits;
1429                         for (x=0; x<width; x++) {
1430                             WORD srcval;
1431                             srcval=*srcpixel++;
1432                             *dstbyte++=X11DRV_DIB_GetNearestIndex
1433                                 (colors, 256,
1434                                  ((srcval >>  7) & 0xf8) | /* r */
1435                                  ((srcval >> 12) & 0x07),
1436                                  ((srcval >>  2) & 0xf8) | /* g */
1437                                  ((srcval >>  7) & 0x07),
1438                                  ((srcval <<  3) & 0xf8) | /* b */
1439                                  ((srcval >>  2) & 0x07) );
1440                         }
1441                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1442                         dstbits += linebytes;
1443                     }
1444                 } else if (bmpImage->blue_mask==0x7c00) {
1445                     /* ==== bgr 555 bmp -> pal 8 dib ==== */
1446                     for (h=0; h<lines; h++) {
1447                         srcpixel=srcbits;
1448                         dstbyte=dstbits;
1449                         for (x=0; x<width; x++) {
1450                             WORD srcval;
1451                             srcval=*srcpixel++;
1452                             *dstbyte++=X11DRV_DIB_GetNearestIndex
1453                                 (colors, 256,
1454                                  ((srcval <<  3) & 0xf8) | /* r */
1455                                  ((srcval >>  2) & 0x07),
1456                                  ((srcval >>  2) & 0xf8) | /* g */
1457                                  ((srcval >>  7) & 0x07),
1458                                  ((srcval >>  7) & 0xf8) | /* b */
1459                                  ((srcval >> 12) & 0x07) );
1460                         }
1461                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1462                         dstbits += linebytes;
1463                     }
1464                 } else {
1465                     goto notsupported;
1466                 }
1467             } else if (bmpImage->green_mask==0x07e0) {
1468                 if (bmpImage->red_mask==0xf800) {
1469                     /* ==== rgb 565 bmp -> pal 8 dib ==== */
1470                     for (h=0; h<lines; h++) {
1471                         srcpixel=srcbits;
1472                         dstbyte=dstbits;
1473                         for (x=0; x<width; x++) {
1474                             WORD srcval;
1475                             srcval=*srcpixel++;
1476                             *dstbyte++=X11DRV_DIB_GetNearestIndex
1477                                 (colors, 256,
1478                                  ((srcval >>  8) & 0xf8) | /* r */
1479                                  ((srcval >> 13) & 0x07),
1480                                  ((srcval >>  3) & 0xfc) | /* g */
1481                                  ((srcval >>  9) & 0x03),
1482                                  ((srcval <<  3) & 0xf8) | /* b */
1483                                  ((srcval >>  2) & 0x07) );
1484                         }
1485                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1486                         dstbits += linebytes;
1487                     }
1488                 } else if (bmpImage->blue_mask==0xf800) {
1489                     /* ==== bgr 565 bmp -> pal 8 dib ==== */
1490                     for (h=0; h<lines; h++) {
1491                         srcpixel=srcbits;
1492                         dstbyte=dstbits;
1493                         for (x=0; x<width; x++) {
1494                             WORD srcval;
1495                             srcval=*srcpixel++;
1496                             *dstbyte++=X11DRV_DIB_GetNearestIndex
1497                                 (colors, 256,
1498                                  ((srcval <<  3) & 0xf8) | /* r */
1499                                  ((srcval >>  2) & 0x07),
1500                                  ((srcval >>  3) & 0xfc) | /* g */
1501                                  ((srcval >>  9) & 0x03),
1502                                  ((srcval >>  8) & 0xf8) | /* b */
1503                                  ((srcval >> 13) & 0x07) );
1504                         }
1505                         srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1506                         dstbits += linebytes;
1507                     }
1508                 } else {
1509                     goto notsupported;
1510                 }
1511             } else {
1512                 goto notsupported;
1513             }
1514         }
1515         break;
1516
1517     case 24:
1518     case 32:
1519         {
1520             const void* srcbits;
1521             const BYTE *srcbyte;
1522             BYTE* dstbyte;
1523             int bytes_per_pixel;
1524
1525             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1526             bytes_per_pixel=(bmpImage->bits_per_pixel==24?3:4);
1527
1528             if (bmpImage->green_mask!=0x00ff00 ||
1529                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
1530                 goto notsupported;
1531             } else if (bmpImage->blue_mask==0xff) {
1532                 /* ==== rgb 888 or 0888 bmp -> pal 8 dib ==== */
1533                 for (h=0; h<lines; h++) {
1534                     srcbyte=srcbits;
1535                     dstbyte=dstbits;
1536                     for (x=0; x<width; x++) {
1537                         *dstbyte++=X11DRV_DIB_GetNearestIndex
1538                             (colors, 256,
1539                              srcbyte[2],
1540                              srcbyte[1],
1541                              srcbyte[0]);
1542                         srcbyte+=bytes_per_pixel;
1543                     }
1544                     srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1545                     dstbits += linebytes;
1546                 }
1547             } else {
1548                 /* ==== bgr 888 or 0888 bmp -> pal 8 dib ==== */
1549                 for (h=0; h<lines; h++) {
1550                     srcbyte=srcbits;
1551                     dstbyte=dstbits;
1552                     for (x=0; x<width; x++) {
1553                         *dstbyte++=X11DRV_DIB_GetNearestIndex
1554                             (colors, 256,
1555                              srcbyte[0],
1556                              srcbyte[1],
1557                              srcbyte[2]);
1558                         srcbyte+=bytes_per_pixel;
1559                     }
1560                     srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
1561                     dstbits += linebytes;
1562                 }
1563             }
1564         }
1565         break;
1566
1567     default:
1568     notsupported:
1569         WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 8 bit DIB\n",
1570               bmpImage->depth, bmpImage->red_mask,
1571               bmpImage->green_mask, bmpImage->blue_mask );
1572     updatesection:
1573         /* ==== any bmp format -> pal 8 dib ==== */
1574         for (h=lines-1; h>=0; h--) {
1575             dstbyte=dstbits;
1576             for (x=0; x<width; x++) {
1577                 *dstbyte=X11DRV_DIB_MapColor
1578                     ((int*)colors, 256,
1579                      XGetPixel(bmpImage, x, h), *dstbyte);
1580                 dstbyte++;
1581             }
1582             dstbits += linebytes;
1583         }
1584         break;
1585     }
1586 }
1587
1588 /***********************************************************************
1589  *           X11DRV_DIB_SetImageBits_16
1590  *
1591  * SetDIBits for a 16-bit deep DIB.
1592  */
1593 static void X11DRV_DIB_SetImageBits_16( int lines, const BYTE *srcbits,
1594                                         DWORD srcwidth, DWORD dstwidth, int left,
1595                                         X11DRV_PDEVICE *physDev, DWORD rSrc, DWORD gSrc, DWORD bSrc,
1596                                         XImage *bmpImage, int linebytes )
1597 {
1598     DWORD x;
1599     int h, width = min(srcwidth, dstwidth);
1600     const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_dst_byteswap;
1601
1602     if (lines < 0 )
1603     {
1604         lines = -lines;
1605         srcbits = srcbits + ( linebytes * (lines-1));
1606         linebytes = -linebytes;
1607     }
1608
1609     switch (bmpImage->depth)
1610     {
1611     case 15:
1612     case 16:
1613         {
1614             char* dstbits;
1615
1616             srcbits=srcbits+left*2;
1617             dstbits=bmpImage->data+left*2+(lines-1)*bmpImage->bytes_per_line;
1618
1619             if (bmpImage->green_mask==0x03e0) {
1620                 if (gSrc==bmpImage->green_mask) {
1621                     if (rSrc==bmpImage->red_mask) {
1622                         /* ==== rgb 555 dib -> rgb 555 bmp ==== */
1623                         /* ==== bgr 555 dib -> bgr 555 bmp ==== */
1624                         convs->Convert_5x5_asis
1625                             (width,lines,
1626                              srcbits,linebytes,
1627                              dstbits,-bmpImage->bytes_per_line);
1628                     } else if (rSrc==bmpImage->blue_mask) {
1629                         /* ==== rgb 555 dib -> bgr 555 bmp ==== */
1630                         /* ==== bgr 555 dib -> rgb 555 bmp ==== */
1631                         convs->Convert_555_reverse
1632                             (width,lines,
1633                              srcbits,linebytes,
1634                              dstbits,-bmpImage->bytes_per_line);
1635                     }
1636                 } else {
1637                     if (rSrc==bmpImage->red_mask || bSrc==bmpImage->blue_mask) {
1638                         /* ==== rgb 565 dib -> rgb 555 bmp ==== */
1639                         /* ==== bgr 565 dib -> bgr 555 bmp ==== */
1640                         convs->Convert_565_to_555_asis
1641                             (width,lines,
1642                              srcbits,linebytes,
1643                              dstbits,-bmpImage->bytes_per_line);
1644                     } else {
1645                         /* ==== rgb 565 dib -> bgr 555 bmp ==== */
1646                         /* ==== bgr 565 dib -> rgb 555 bmp ==== */
1647                         convs->Convert_565_to_555_reverse
1648                             (width,lines,
1649                              srcbits,linebytes,
1650                              dstbits,-bmpImage->bytes_per_line);
1651                     }
1652                 }
1653             } else if (bmpImage->green_mask==0x07e0) {
1654                 if (gSrc==bmpImage->green_mask) {
1655                     if (rSrc==bmpImage->red_mask) {
1656                         /* ==== rgb 565 dib -> rgb 565 bmp ==== */
1657                         /* ==== bgr 565 dib -> bgr 565 bmp ==== */
1658                         convs->Convert_5x5_asis
1659                             (width,lines,
1660                              srcbits,linebytes,
1661                              dstbits,-bmpImage->bytes_per_line);
1662                     } else {
1663                         /* ==== rgb 565 dib -> bgr 565 bmp ==== */
1664                         /* ==== bgr 565 dib -> rgb 565 bmp ==== */
1665                         convs->Convert_565_reverse
1666                             (width,lines,
1667                              srcbits,linebytes,
1668                              dstbits,-bmpImage->bytes_per_line);
1669                     }
1670                 } else {
1671                     if (rSrc==bmpImage->red_mask || bSrc==bmpImage->blue_mask) {
1672                         /* ==== rgb 555 dib -> rgb 565 bmp ==== */
1673                         /* ==== bgr 555 dib -> bgr 565 bmp ==== */
1674                         convs->Convert_555_to_565_asis
1675                             (width,lines,
1676                              srcbits,linebytes,
1677                              dstbits,-bmpImage->bytes_per_line);
1678                     } else {
1679                         /* ==== rgb 555 dib -> bgr 565 bmp ==== */
1680                         /* ==== bgr 555 dib -> rgb 565 bmp ==== */
1681                         convs->Convert_555_to_565_reverse
1682                             (width,lines,
1683                              srcbits,linebytes,
1684                              dstbits,-bmpImage->bytes_per_line);
1685                     }
1686                 }
1687             } else {
1688                 goto notsupported;
1689             }
1690         }
1691         break;
1692
1693     case 24:
1694         if (bmpImage->bits_per_pixel==24) {
1695             char* dstbits;
1696
1697             srcbits=srcbits+left*2;
1698             dstbits=bmpImage->data+left*3+(lines-1)*bmpImage->bytes_per_line;
1699
1700             if (bmpImage->green_mask!=0x00ff00 ||
1701                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
1702                 goto notsupported;
1703             } else if ((rSrc==0x1f && bmpImage->red_mask==0xff) ||
1704                        (bSrc==0x1f && bmpImage->blue_mask==0xff)) {
1705                 if (gSrc==0x03e0) {
1706                     /* ==== rgb 555 dib -> rgb 888 bmp ==== */
1707                     /* ==== bgr 555 dib -> bgr 888 bmp ==== */
1708                     convs->Convert_555_to_888_asis
1709                         (width,lines,
1710                          srcbits,linebytes,
1711                          dstbits,-bmpImage->bytes_per_line);
1712                 } else {
1713                     /* ==== rgb 565 dib -> rgb 888 bmp ==== */
1714                     /* ==== bgr 565 dib -> bgr 888 bmp ==== */
1715                     convs->Convert_565_to_888_asis
1716                         (width,lines,
1717                          srcbits,linebytes,
1718                          dstbits,-bmpImage->bytes_per_line);
1719                 }
1720             } else {
1721                 if (gSrc==0x03e0) {
1722                     /* ==== rgb 555 dib -> bgr 888 bmp ==== */
1723                     /* ==== bgr 555 dib -> rgb 888 bmp ==== */
1724                     convs->Convert_555_to_888_reverse
1725                         (width,lines,
1726                          srcbits,linebytes,
1727                          dstbits,-bmpImage->bytes_per_line);
1728                 } else {
1729                     /* ==== rgb 565 dib -> bgr 888 bmp ==== */
1730                     /* ==== bgr 565 dib -> rgb 888 bmp ==== */
1731                     convs->Convert_565_to_888_reverse
1732                         (width,lines,
1733                          srcbits,linebytes,
1734                          dstbits,-bmpImage->bytes_per_line);
1735                 }
1736             }
1737             break;
1738         }
1739         /* Fall through */
1740
1741     case 32:
1742         {
1743             char* dstbits;
1744
1745             srcbits=srcbits+left*2;
1746             dstbits=bmpImage->data+left*4+(lines-1)*bmpImage->bytes_per_line;
1747
1748             if (bmpImage->green_mask!=0x00ff00 ||
1749                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
1750                 goto notsupported;
1751             } else if ((rSrc==0x1f && bmpImage->red_mask==0xff) ||
1752                        (bSrc==0x1f && bmpImage->blue_mask==0xff)) {
1753                 if (gSrc==0x03e0) {
1754                     /* ==== rgb 555 dib -> rgb 0888 bmp ==== */
1755                     /* ==== bgr 555 dib -> bgr 0888 bmp ==== */
1756                     convs->Convert_555_to_0888_asis
1757                         (width,lines,
1758                          srcbits,linebytes,
1759                          dstbits,-bmpImage->bytes_per_line);
1760                 } else {
1761                     /* ==== rgb 565 dib -> rgb 0888 bmp ==== */
1762                     /* ==== bgr 565 dib -> bgr 0888 bmp ==== */
1763                     convs->Convert_565_to_0888_asis
1764                         (width,lines,
1765                          srcbits,linebytes,
1766                          dstbits,-bmpImage->bytes_per_line);
1767                 }
1768             } else {
1769                 if (gSrc==0x03e0) {
1770                     /* ==== rgb 555 dib -> bgr 0888 bmp ==== */
1771                     /* ==== bgr 555 dib -> rgb 0888 bmp ==== */
1772                     convs->Convert_555_to_0888_reverse
1773                         (width,lines,
1774                          srcbits,linebytes,
1775                          dstbits,-bmpImage->bytes_per_line);
1776                 } else {
1777                     /* ==== rgb 565 dib -> bgr 0888 bmp ==== */
1778                     /* ==== bgr 565 dib -> rgb 0888 bmp ==== */
1779                     convs->Convert_565_to_0888_reverse
1780                         (width,lines,
1781                          srcbits,linebytes,
1782                          dstbits,-bmpImage->bytes_per_line);
1783                 }
1784             }
1785         }
1786         break;
1787
1788     default:
1789     notsupported:
1790         WARN("from 16 bit DIB (%x,%x,%x) to unknown %d bit bitmap (%lx,%lx,%lx)\n",
1791               rSrc, gSrc, bSrc, bmpImage->bits_per_pixel, bmpImage->red_mask,
1792               bmpImage->green_mask, bmpImage->blue_mask );
1793         /* fall through */
1794     case 1:
1795     case 4:
1796     case 8:
1797         {
1798             /* ==== rgb or bgr 555 or 565 dib -> pal 1, 4 or 8 ==== */
1799             const WORD* srcpixel;
1800             int rShift1,gShift1,bShift1;
1801             int rShift2,gShift2,bShift2;
1802             BYTE gMask1,gMask2;
1803
1804             /* Set color scaling values */
1805             rShift1=16+X11DRV_DIB_MaskToShift(rSrc)-3;
1806             gShift1=16+X11DRV_DIB_MaskToShift(gSrc)-3;
1807             bShift1=16+X11DRV_DIB_MaskToShift(bSrc)-3;
1808             rShift2=rShift1+5;
1809             gShift2=gShift1+5;
1810             bShift2=bShift1+5;
1811             if (gSrc==0x03e0) {
1812                 /* Green has 5 bits, like the others */
1813                 gMask1=0xf8;
1814                 gMask2=0x07;
1815             } else {
1816                 /* Green has 6 bits, not 5. Compensate. */
1817                 gShift1++;
1818                 gShift2+=2;
1819                 gMask1=0xfc;
1820                 gMask2=0x03;
1821             }
1822
1823             srcbits+=2*left;
1824
1825             /* We could split it into four separate cases to optimize
1826              * but it is probably not worth it.
1827              */
1828             for (h=lines-1; h>=0; h--) {
1829                 srcpixel=(const WORD*)srcbits;
1830                 for (x=left; x<width+left; x++) {
1831                     DWORD srcval;
1832                     BYTE red,green,blue;
1833                     srcval=*srcpixel++ << 16;
1834                     red=  ((srcval >> rShift1) & 0xf8) |
1835                         ((srcval >> rShift2) & 0x07);
1836                     green=((srcval >> gShift1) & gMask1) |
1837                         ((srcval >> gShift2) & gMask2);
1838                     blue= ((srcval >> bShift1) & 0xf8) |
1839                         ((srcval >> bShift2) & 0x07);
1840                     XPutPixel(bmpImage, x, h,
1841                               X11DRV_PALETTE_ToPhysical
1842                               (physDev, RGB(red,green,blue)));
1843                 }
1844                 srcbits += linebytes;
1845             }
1846         }
1847         break;
1848     }
1849 }
1850
1851
1852 /***********************************************************************
1853  *           X11DRV_DIB_GetImageBits_16
1854  *
1855  * GetDIBits for an 16-bit deep DIB.
1856  */
1857 static void X11DRV_DIB_GetImageBits_16( X11DRV_PDEVICE *physDev, int lines, BYTE *dstbits,
1858                                         DWORD dstwidth, DWORD srcwidth,
1859                                         PALETTEENTRY *srccolors,
1860                                         DWORD rDst, DWORD gDst, DWORD bDst,
1861                                         XImage *bmpImage, int linebytes )
1862 {
1863     DWORD x;
1864     int h, width = min(srcwidth, dstwidth);
1865     const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_src_byteswap;
1866
1867     if (lines < 0 )
1868     {
1869         lines = -lines;
1870         dstbits = dstbits + ( linebytes * (lines-1));
1871         linebytes = -linebytes;
1872     }
1873
1874     switch (bmpImage->depth)
1875     {
1876     case 15:
1877     case 16:
1878         {
1879             const char* srcbits;
1880
1881             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1882
1883             if (bmpImage->green_mask==0x03e0) {
1884                 if (gDst==bmpImage->green_mask) {
1885                     if (rDst==bmpImage->red_mask) {
1886                         /* ==== rgb 555 bmp -> rgb 555 dib ==== */
1887                         /* ==== bgr 555 bmp -> bgr 555 dib ==== */
1888                         convs->Convert_5x5_asis
1889                             (width,lines,
1890                              srcbits,-bmpImage->bytes_per_line,
1891                              dstbits,linebytes);
1892                     } else {
1893                         /* ==== rgb 555 bmp -> bgr 555 dib ==== */
1894                         /* ==== bgr 555 bmp -> rgb 555 dib ==== */
1895                         convs->Convert_555_reverse
1896                             (width,lines,
1897                              srcbits,-bmpImage->bytes_per_line,
1898                              dstbits,linebytes);
1899                     }
1900                 } else {
1901                     if (rDst==bmpImage->red_mask || bDst==bmpImage->blue_mask) {
1902                         /* ==== rgb 555 bmp -> rgb 565 dib ==== */
1903                         /* ==== bgr 555 bmp -> bgr 565 dib ==== */
1904                         convs->Convert_555_to_565_asis
1905                             (width,lines,
1906                              srcbits,-bmpImage->bytes_per_line,
1907                              dstbits,linebytes);
1908                     } else {
1909                         /* ==== rgb 555 bmp -> bgr 565 dib ==== */
1910                         /* ==== bgr 555 bmp -> rgb 565 dib ==== */
1911                         convs->Convert_555_to_565_reverse
1912                             (width,lines,
1913                              srcbits,-bmpImage->bytes_per_line,
1914                              dstbits,linebytes);
1915                     }
1916                 }
1917             } else if (bmpImage->green_mask==0x07e0) {
1918                 if (gDst==bmpImage->green_mask) {
1919                     if (rDst == bmpImage->red_mask) {
1920                         /* ==== rgb 565 bmp -> rgb 565 dib ==== */
1921                         /* ==== bgr 565 bmp -> bgr 565 dib ==== */
1922                         convs->Convert_5x5_asis
1923                             (width,lines,
1924                              srcbits,-bmpImage->bytes_per_line,
1925                              dstbits,linebytes);
1926                     } else {
1927                         /* ==== rgb 565 bmp -> bgr 565 dib ==== */
1928                         /* ==== bgr 565 bmp -> rgb 565 dib ==== */
1929                         convs->Convert_565_reverse
1930                             (width,lines,
1931                              srcbits,-bmpImage->bytes_per_line,
1932                              dstbits,linebytes);
1933                     }
1934                 } else {
1935                     if (rDst==bmpImage->red_mask || bDst==bmpImage->blue_mask) {
1936                         /* ==== rgb 565 bmp -> rgb 555 dib ==== */
1937                         /* ==== bgr 565 bmp -> bgr 555 dib ==== */
1938                         convs->Convert_565_to_555_asis
1939                             (width,lines,
1940                              srcbits,-bmpImage->bytes_per_line,
1941                              dstbits,linebytes);
1942                     } else {
1943                         /* ==== rgb 565 bmp -> bgr 555 dib ==== */
1944                         /* ==== bgr 565 bmp -> rgb 555 dib ==== */
1945                         convs->Convert_565_to_555_reverse
1946                             (width,lines,
1947                              srcbits,-bmpImage->bytes_per_line,
1948                              dstbits,linebytes);
1949                     }
1950                 }
1951             } else {
1952                 goto notsupported;
1953             }
1954         }
1955         break;
1956
1957     case 24:
1958         if (bmpImage->bits_per_pixel == 24) {
1959             const char* srcbits;
1960
1961             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1962
1963             if (bmpImage->green_mask!=0x00ff00 ||
1964                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
1965                 goto notsupported;
1966             } else if ((rDst==0x1f && bmpImage->red_mask==0xff) ||
1967                     (bDst==0x1f && bmpImage->blue_mask==0xff)) {
1968                 if (gDst==0x03e0) {
1969                     /* ==== rgb 888 bmp -> rgb 555 dib ==== */
1970                     /* ==== bgr 888 bmp -> bgr 555 dib ==== */
1971                     convs->Convert_888_to_555_asis
1972                         (width,lines,
1973                          srcbits,-bmpImage->bytes_per_line,
1974                          dstbits,linebytes);
1975                 } else {
1976                     /* ==== rgb 888 bmp -> rgb 565 dib ==== */
1977                     /* ==== rgb 888 bmp -> rgb 565 dib ==== */
1978                     convs->Convert_888_to_565_asis
1979                         (width,lines,
1980                          srcbits,-bmpImage->bytes_per_line,
1981                          dstbits,linebytes);
1982                 }
1983             } else {
1984                 if (gDst==0x03e0) {
1985                     /* ==== rgb 888 bmp -> bgr 555 dib ==== */
1986                     /* ==== bgr 888 bmp -> rgb 555 dib ==== */
1987                     convs->Convert_888_to_555_reverse
1988                         (width,lines,
1989                          srcbits,-bmpImage->bytes_per_line,
1990                          dstbits,linebytes);
1991                 } else {
1992                     /* ==== rgb 888 bmp -> bgr 565 dib ==== */
1993                     /* ==== bgr 888 bmp -> rgb 565 dib ==== */
1994                     convs->Convert_888_to_565_reverse
1995                         (width,lines,
1996                          srcbits,-bmpImage->bytes_per_line,
1997                          dstbits,linebytes);
1998                 }
1999             }
2000             break;
2001         }
2002         /* Fall through */
2003
2004     case 32:
2005         {
2006             const char* srcbits;
2007
2008             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2009
2010             if (bmpImage->green_mask!=0x00ff00 ||
2011                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2012                 goto notsupported;
2013             } else if ((rDst==0x1f && bmpImage->red_mask==0xff) ||
2014                        (bDst==0x1f && bmpImage->blue_mask==0xff)) {
2015                 if (gDst==0x03e0) {
2016                     /* ==== rgb 0888 bmp -> rgb 555 dib ==== */
2017                     /* ==== bgr 0888 bmp -> bgr 555 dib ==== */
2018                     convs->Convert_0888_to_555_asis
2019                         (width,lines,
2020                          srcbits,-bmpImage->bytes_per_line,
2021                          dstbits,linebytes);
2022                 } else {
2023                     /* ==== rgb 0888 bmp -> rgb 565 dib ==== */
2024                     /* ==== bgr 0888 bmp -> bgr 565 dib ==== */
2025                     convs->Convert_0888_to_565_asis
2026                         (width,lines,
2027                          srcbits,-bmpImage->bytes_per_line,
2028                          dstbits,linebytes);
2029                 }
2030             } else {
2031                 if (gDst==0x03e0) {
2032                     /* ==== rgb 0888 bmp -> bgr 555 dib ==== */
2033                     /* ==== bgr 0888 bmp -> rgb 555 dib ==== */
2034                     convs->Convert_0888_to_555_reverse
2035                         (width,lines,
2036                          srcbits,-bmpImage->bytes_per_line,
2037                          dstbits,linebytes);
2038                 } else {
2039                     /* ==== rgb 0888 bmp -> bgr 565 dib ==== */
2040                     /* ==== bgr 0888 bmp -> rgb 565 dib ==== */
2041                     convs->Convert_0888_to_565_reverse
2042                         (width,lines,
2043                          srcbits,-bmpImage->bytes_per_line,
2044                          dstbits,linebytes);
2045                 }
2046             }
2047         }
2048         break;
2049
2050     case 1:
2051     case 4:
2052         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
2053             && srccolors) {
2054             /* ==== pal 1 or 4 bmp -> rgb or bgr 555 or 565 dib ==== */
2055             int rShift,gShift,bShift;
2056             WORD* dstpixel;
2057
2058             /* Shift everything 16 bits left so that all shifts are >0,
2059              * even for BGR DIBs. Then a single >> 16 will bring everything
2060              * back into place.
2061              */
2062             rShift=16+X11DRV_DIB_MaskToShift(rDst)-3;
2063             gShift=16+X11DRV_DIB_MaskToShift(gDst)-3;
2064             bShift=16+X11DRV_DIB_MaskToShift(bDst)-3;
2065             if (gDst==0x07e0) {
2066                 /* 6 bits for the green */
2067                 gShift++;
2068             }
2069             rDst=rDst << 16;
2070             gDst=gDst << 16;
2071             bDst=bDst << 16;
2072             for (h = lines - 1; h >= 0; h--) {
2073                 dstpixel=(LPWORD)dstbits;
2074                 for (x = 0; x < width; x++) {
2075                     PALETTEENTRY srcval;
2076                     DWORD dstval;
2077                     srcval=srccolors[XGetPixel(bmpImage, x, h)];
2078                     dstval=((srcval.peRed   << rShift) & rDst) |
2079                            ((srcval.peGreen << gShift) & gDst) |
2080                            ((srcval.peBlue  << bShift) & bDst);
2081                     *dstpixel++=dstval >> 16;
2082                 }
2083                 dstbits += linebytes;
2084             }
2085         } else {
2086             goto notsupported;
2087         }
2088         break;
2089
2090     case 8:
2091         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
2092             && srccolors) {
2093             /* ==== pal 8 bmp -> rgb or bgr 555 or 565 dib ==== */
2094             int rShift,gShift,bShift;
2095             const BYTE* srcbits;
2096             const BYTE* srcpixel;
2097             WORD* dstpixel;
2098
2099             /* Shift everything 16 bits left so that all shifts are >0,
2100              * even for BGR DIBs. Then a single >> 16 will bring everything
2101              * back into place.
2102              */
2103             rShift=16+X11DRV_DIB_MaskToShift(rDst)-3;
2104             gShift=16+X11DRV_DIB_MaskToShift(gDst)-3;
2105             bShift=16+X11DRV_DIB_MaskToShift(bDst)-3;
2106             if (gDst==0x07e0) {
2107                 /* 6 bits for the green */
2108                 gShift++;
2109             }
2110             rDst=rDst << 16;
2111             gDst=gDst << 16;
2112             bDst=bDst << 16;
2113             srcbits=(BYTE*)bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2114             for (h=0; h<lines; h++) {
2115                 srcpixel=srcbits;
2116                 dstpixel=(LPWORD)dstbits;
2117                 for (x = 0; x < width; x++) {
2118                     PALETTEENTRY srcval;
2119                     DWORD dstval;
2120                     srcval=srccolors[*srcpixel++];
2121                     dstval=((srcval.peRed   << rShift) & rDst) |
2122                            ((srcval.peGreen << gShift) & gDst) |
2123                            ((srcval.peBlue  << bShift) & bDst);
2124                     *dstpixel++=dstval >> 16;
2125                 }
2126                 srcbits -= bmpImage->bytes_per_line;
2127                 dstbits += linebytes;
2128             }
2129         } else {
2130             goto notsupported;
2131         }
2132         break;
2133
2134     default:
2135     notsupported:
2136         {
2137             /* ==== any bmp format -> rgb or bgr 555 or 565 dib ==== */
2138             int rShift,gShift,bShift;
2139             WORD* dstpixel;
2140
2141             WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 16 bit DIB (%x,%x,%x)\n",
2142                   bmpImage->depth, bmpImage->red_mask,
2143                   bmpImage->green_mask, bmpImage->blue_mask,
2144                   rDst, gDst, bDst);
2145
2146             /* Shift everything 16 bits left so that all shifts are >0,
2147              * even for BGR DIBs. Then a single >> 16 will bring everything
2148              * back into place.
2149              */
2150             rShift=16+X11DRV_DIB_MaskToShift(rDst)-3;
2151             gShift=16+X11DRV_DIB_MaskToShift(gDst)-3;
2152             bShift=16+X11DRV_DIB_MaskToShift(bDst)-3;
2153             if (gDst==0x07e0) {
2154                 /* 6 bits for the green */
2155                 gShift++;
2156             }
2157             rDst=rDst << 16;
2158             gDst=gDst << 16;
2159             bDst=bDst << 16;
2160             for (h = lines - 1; h >= 0; h--) {
2161                 dstpixel=(LPWORD)dstbits;
2162                 for (x = 0; x < width; x++) {
2163                     COLORREF srcval;
2164                     DWORD dstval;
2165                     srcval=X11DRV_PALETTE_ToLogical(physDev, XGetPixel(bmpImage, x, h));
2166                     dstval=((GetRValue(srcval) << rShift) & rDst) |
2167                            ((GetGValue(srcval) << gShift) & gDst) |
2168                            ((GetBValue(srcval) << bShift) & bDst);
2169                     *dstpixel++=dstval >> 16;
2170                 }
2171                 dstbits += linebytes;
2172             }
2173         }
2174         break;
2175     }
2176 }
2177
2178
2179 /***********************************************************************
2180  *           X11DRV_DIB_SetImageBits_24
2181  *
2182  * SetDIBits for a 24-bit deep DIB.
2183  */
2184 static void X11DRV_DIB_SetImageBits_24( int lines, const BYTE *srcbits,
2185                                  DWORD srcwidth, DWORD dstwidth, int left,
2186                                  X11DRV_PDEVICE *physDev,
2187                                  DWORD rSrc, DWORD gSrc, DWORD bSrc,
2188                                  XImage *bmpImage, DWORD linebytes )
2189 {
2190     DWORD x;
2191     int h, width = min(srcwidth, dstwidth);
2192     const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_dst_byteswap;
2193
2194     if (lines < 0 )
2195     {
2196         lines = -lines;
2197         srcbits = srcbits + linebytes * (lines - 1);
2198         linebytes = -linebytes;
2199     }
2200
2201     switch (bmpImage->depth)
2202     {
2203     case 24:
2204         if (bmpImage->bits_per_pixel==24) {
2205             char* dstbits;
2206
2207             srcbits=srcbits+left*3;
2208             dstbits=bmpImage->data+left*3+(lines-1)*bmpImage->bytes_per_line;
2209
2210             if (bmpImage->green_mask!=0x00ff00 ||
2211                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2212                 goto notsupported;
2213             } else if (rSrc==bmpImage->red_mask) {
2214                 /* ==== rgb 888 dib -> rgb 888 bmp ==== */
2215                 /* ==== bgr 888 dib -> bgr 888 bmp ==== */
2216                 convs->Convert_888_asis
2217                     (width,lines,
2218                      srcbits,linebytes,
2219                      dstbits,-bmpImage->bytes_per_line);
2220             } else {
2221                 /* ==== rgb 888 dib -> bgr 888 bmp ==== */
2222                 /* ==== bgr 888 dib -> rgb 888 bmp ==== */
2223                 convs->Convert_888_reverse
2224                     (width,lines,
2225                      srcbits,linebytes,
2226                      dstbits,-bmpImage->bytes_per_line);
2227             }
2228             break;
2229         }
2230         /* fall through */
2231
2232     case 32:
2233         {
2234             char* dstbits;
2235
2236             srcbits=srcbits+left*3;
2237             dstbits=bmpImage->data+left*4+(lines-1)*bmpImage->bytes_per_line;
2238
2239             if (bmpImage->green_mask!=0x00ff00 ||
2240                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2241                 goto notsupported;
2242             } else if (rSrc==bmpImage->red_mask) {
2243                 /* ==== rgb 888 dib -> rgb 0888 bmp ==== */
2244                 /* ==== bgr 888 dib -> bgr 0888 bmp ==== */
2245                 convs->Convert_888_to_0888_asis
2246                     (width,lines,
2247                      srcbits,linebytes,
2248                      dstbits,-bmpImage->bytes_per_line);
2249             } else {
2250                 /* ==== rgb 888 dib -> bgr 0888 bmp ==== */
2251                 /* ==== bgr 888 dib -> rgb 0888 bmp ==== */
2252                 convs->Convert_888_to_0888_reverse
2253                     (width,lines,
2254                      srcbits,linebytes,
2255                      dstbits,-bmpImage->bytes_per_line);
2256             }
2257             break;
2258         }
2259
2260     case 15:
2261     case 16:
2262         {
2263             char* dstbits;
2264
2265             srcbits=srcbits+left*3;
2266             dstbits=bmpImage->data+left*2+(lines-1)*bmpImage->bytes_per_line;
2267
2268             if (bmpImage->green_mask==0x03e0) {
2269                 if ((rSrc==0xff0000 && bmpImage->red_mask==0x7f00) ||
2270                     (bSrc==0xff0000 && bmpImage->blue_mask==0x7f00)) {
2271                     /* ==== rgb 888 dib -> rgb 555 bmp ==== */
2272                     /* ==== bgr 888 dib -> bgr 555 bmp ==== */
2273                     convs->Convert_888_to_555_asis
2274                         (width,lines,
2275                          srcbits,linebytes,
2276                          dstbits,-bmpImage->bytes_per_line);
2277                 } else if ((rSrc==0xff && bmpImage->red_mask==0x7f00) ||
2278                            (bSrc==0xff && bmpImage->blue_mask==0x7f00)) {
2279                     /* ==== rgb 888 dib -> bgr 555 bmp ==== */
2280                     /* ==== bgr 888 dib -> rgb 555 bmp ==== */
2281                     convs->Convert_888_to_555_reverse
2282                         (width,lines,
2283                          srcbits,linebytes,
2284                          dstbits,-bmpImage->bytes_per_line);
2285                 } else {
2286                     goto notsupported;
2287                 }
2288             } else if (bmpImage->green_mask==0x07e0) {
2289                 if ((rSrc==0xff0000 && bmpImage->red_mask==0xf800) ||
2290                     (bSrc==0xff0000 && bmpImage->blue_mask==0xf800)) {
2291                     /* ==== rgb 888 dib -> rgb 565 bmp ==== */
2292                     /* ==== bgr 888 dib -> bgr 565 bmp ==== */
2293                     convs->Convert_888_to_565_asis
2294                         (width,lines,
2295                          srcbits,linebytes,
2296                          dstbits,-bmpImage->bytes_per_line);
2297                 } else if ((rSrc==0xff && bmpImage->red_mask==0xf800) ||
2298                            (bSrc==0xff && bmpImage->blue_mask==0xf800)) {
2299                     /* ==== rgb 888 dib -> bgr 565 bmp ==== */
2300                     /* ==== bgr 888 dib -> rgb 565 bmp ==== */
2301                     convs->Convert_888_to_565_reverse
2302                         (width,lines,
2303                          srcbits,linebytes,
2304                          dstbits,-bmpImage->bytes_per_line);
2305                 } else {
2306                     goto notsupported;
2307                 }
2308             } else {
2309                 goto notsupported;
2310             }
2311         }
2312         break;
2313
2314     default:
2315     notsupported:
2316         WARN("from 24 bit DIB (%x,%x,%x) to unknown %d bit bitmap (%lx,%lx,%lx)\n",
2317               rSrc, gSrc, bSrc, bmpImage->bits_per_pixel, bmpImage->red_mask,
2318               bmpImage->green_mask, bmpImage->blue_mask );
2319         /* fall through */
2320     case 1:
2321     case 4:
2322     case 8:
2323         {
2324             /* ==== rgb 888 dib -> any bmp format ==== */
2325             const BYTE* srcbyte;
2326
2327             /* Windows only supports one 24bpp DIB format: RGB888 */
2328             srcbits+=left*3;
2329             for (h = lines - 1; h >= 0; h--) {
2330                 srcbyte = srcbits;
2331                 for (x = left; x < width+left; x++) {
2332                     XPutPixel(bmpImage, x, h,
2333                               X11DRV_PALETTE_ToPhysical
2334                               (physDev, RGB(srcbyte[2], srcbyte[1], srcbyte[0])));
2335                     srcbyte+=3;
2336                 }
2337                 srcbits += linebytes;
2338             }
2339         }
2340         break;
2341     }
2342 }
2343
2344
2345 /***********************************************************************
2346  *           X11DRV_DIB_GetImageBits_24
2347  *
2348  * GetDIBits for an 24-bit deep DIB.
2349  */
2350 static void X11DRV_DIB_GetImageBits_24( X11DRV_PDEVICE *physDev, int lines, BYTE *dstbits,
2351                                         DWORD dstwidth, DWORD srcwidth,
2352                                         PALETTEENTRY *srccolors,
2353                                         DWORD rDst, DWORD gDst, DWORD bDst,
2354                                         XImage *bmpImage, DWORD linebytes )
2355 {
2356     DWORD x;
2357     int h, width = min(srcwidth, dstwidth);
2358     const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_src_byteswap;
2359
2360     if (lines < 0 )
2361     {
2362         lines = -lines;
2363         dstbits = dstbits + ( linebytes * (lines-1) );
2364         linebytes = -linebytes;
2365     }
2366
2367     switch (bmpImage->depth)
2368     {
2369     case 24:
2370         if (bmpImage->bits_per_pixel==24) {
2371             const char* srcbits;
2372
2373             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2374
2375             if (bmpImage->green_mask!=0x00ff00 ||
2376                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2377                 goto notsupported;
2378             } else if (rDst==bmpImage->red_mask) {
2379                 /* ==== rgb 888 bmp -> rgb 888 dib ==== */
2380                 /* ==== bgr 888 bmp -> bgr 888 dib ==== */
2381                 convs->Convert_888_asis
2382                     (width,lines,
2383                      srcbits,-bmpImage->bytes_per_line,
2384                      dstbits,linebytes);
2385             } else {
2386                 /* ==== rgb 888 bmp -> bgr 888 dib ==== */
2387                 /* ==== bgr 888 bmp -> rgb 888 dib ==== */
2388                 convs->Convert_888_reverse
2389                     (width,lines,
2390                      srcbits,-bmpImage->bytes_per_line,
2391                      dstbits,linebytes);
2392             }
2393             break;
2394         }
2395         /* fall through */
2396
2397     case 32:
2398         {
2399             const char* srcbits;
2400
2401             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2402
2403             if (bmpImage->green_mask!=0x00ff00 ||
2404                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2405                 goto notsupported;
2406             } else if (rDst==bmpImage->red_mask) {
2407                 /* ==== rgb 888 bmp -> rgb 0888 dib ==== */
2408                 /* ==== bgr 888 bmp -> bgr 0888 dib ==== */
2409                 convs->Convert_0888_to_888_asis
2410                     (width,lines,
2411                      srcbits,-bmpImage->bytes_per_line,
2412                      dstbits,linebytes);
2413             } else {
2414                 /* ==== rgb 888 bmp -> bgr 0888 dib ==== */
2415                 /* ==== bgr 888 bmp -> rgb 0888 dib ==== */
2416                 convs->Convert_0888_to_888_reverse
2417                     (width,lines,
2418                      srcbits,-bmpImage->bytes_per_line,
2419                      dstbits,linebytes);
2420             }
2421             break;
2422         }
2423
2424     case 15:
2425     case 16:
2426         {
2427             const char* srcbits;
2428
2429             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2430
2431             if (bmpImage->green_mask==0x03e0) {
2432                 if ((rDst==0xff0000 && bmpImage->red_mask==0x7f00) ||
2433                     (bDst==0xff0000 && bmpImage->blue_mask==0x7f00)) {
2434                     /* ==== rgb 555 bmp -> rgb 888 dib ==== */
2435                     /* ==== bgr 555 bmp -> bgr 888 dib ==== */
2436                     convs->Convert_555_to_888_asis
2437                         (width,lines,
2438                          srcbits,-bmpImage->bytes_per_line,
2439                          dstbits,linebytes);
2440                 } else if ((rDst==0xff && bmpImage->red_mask==0x7f00) ||
2441                            (bDst==0xff && bmpImage->blue_mask==0x7f00)) {
2442                     /* ==== rgb 555 bmp -> bgr 888 dib ==== */
2443                     /* ==== bgr 555 bmp -> rgb 888 dib ==== */
2444                     convs->Convert_555_to_888_reverse
2445                         (width,lines,
2446                          srcbits,-bmpImage->bytes_per_line,
2447                          dstbits,linebytes);
2448                 } else {
2449                     goto notsupported;
2450                 }
2451             } else if (bmpImage->green_mask==0x07e0) {
2452                 if ((rDst==0xff0000 && bmpImage->red_mask==0xf800) ||
2453                     (bDst==0xff0000 && bmpImage->blue_mask==0xf800)) {
2454                     /* ==== rgb 565 bmp -> rgb 888 dib ==== */
2455                     /* ==== bgr 565 bmp -> bgr 888 dib ==== */
2456                     convs->Convert_565_to_888_asis
2457                         (width,lines,
2458                          srcbits,-bmpImage->bytes_per_line,
2459                          dstbits,linebytes);
2460                 } else if ((rDst==0xff && bmpImage->red_mask==0xf800) ||
2461                            (bDst==0xff && bmpImage->blue_mask==0xf800)) {
2462                     /* ==== rgb 565 bmp -> bgr 888 dib ==== */
2463                     /* ==== bgr 565 bmp -> rgb 888 dib ==== */
2464                     convs->Convert_565_to_888_reverse
2465                         (width,lines,
2466                          srcbits,-bmpImage->bytes_per_line,
2467                          dstbits,linebytes);
2468                 } else {
2469                     goto notsupported;
2470                 }
2471             } else {
2472                 goto notsupported;
2473             }
2474         }
2475         break;
2476
2477     case 1:
2478     case 4:
2479         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
2480             && srccolors) {
2481             /* ==== pal 1 or 4 bmp -> rgb 888 dib ==== */
2482             BYTE* dstbyte;
2483
2484             /* Windows only supports one 24bpp DIB format: rgb 888 */
2485             for (h = lines - 1; h >= 0; h--) {
2486                 dstbyte=dstbits;
2487                 for (x = 0; x < width; x++) {
2488                     PALETTEENTRY srcval;
2489                     srcval=srccolors[XGetPixel(bmpImage, x, h)];
2490                     dstbyte[0]=srcval.peBlue;
2491                     dstbyte[1]=srcval.peGreen;
2492                     dstbyte[2]=srcval.peRed;
2493                     dstbyte+=3;
2494                 }
2495                 dstbits += linebytes;
2496             }
2497         } else {
2498             goto notsupported;
2499         }
2500         break;
2501
2502     case 8:
2503         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
2504             && srccolors) {
2505             /* ==== pal 8 bmp -> rgb 888 dib ==== */
2506             const void* srcbits;
2507             const BYTE* srcpixel;
2508             BYTE* dstbyte;
2509
2510             /* Windows only supports one 24bpp DIB format: rgb 888 */
2511             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2512             for (h = lines - 1; h >= 0; h--) {
2513                 srcpixel=srcbits;
2514                 dstbyte=dstbits;
2515                 for (x = 0; x < width; x++ ) {
2516                     PALETTEENTRY srcval;
2517                     srcval=srccolors[*srcpixel++];
2518                     dstbyte[0]=srcval.peBlue;
2519                     dstbyte[1]=srcval.peGreen;
2520                     dstbyte[2]=srcval.peRed;
2521                     dstbyte+=3;
2522                 }
2523                 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
2524                 dstbits += linebytes;
2525             }
2526         } else {
2527             goto notsupported;
2528         }
2529         break;
2530
2531     default:
2532     notsupported:
2533         {
2534             /* ==== any bmp format -> 888 dib ==== */
2535             BYTE* dstbyte;
2536
2537             WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 24 bit DIB (%x,%x,%x)\n",
2538                   bmpImage->depth, bmpImage->red_mask,
2539                   bmpImage->green_mask, bmpImage->blue_mask,
2540                   rDst, gDst, bDst );
2541
2542             /* Windows only supports one 24bpp DIB format: rgb 888 */
2543             for (h = lines - 1; h >= 0; h--) {
2544                 dstbyte=dstbits;
2545                 for (x = 0; x < width; x++) {
2546                     COLORREF srcval=X11DRV_PALETTE_ToLogical
2547                         (physDev, XGetPixel( bmpImage, x, h ));
2548                     dstbyte[0]=GetBValue(srcval);
2549                     dstbyte[1]=GetGValue(srcval);
2550                     dstbyte[2]=GetRValue(srcval);
2551                     dstbyte+=3;
2552                 }
2553                 dstbits += linebytes;
2554             }
2555         }
2556         break;
2557     }
2558 }
2559
2560
2561 /***********************************************************************
2562  *           X11DRV_DIB_SetImageBits_32
2563  *
2564  * SetDIBits for a 32-bit deep DIB.
2565  */
2566 static void X11DRV_DIB_SetImageBits_32(int lines, const BYTE *srcbits,
2567                                        DWORD srcwidth, DWORD dstwidth, int left,
2568                                        X11DRV_PDEVICE *physDev,
2569                                        DWORD rSrc, DWORD gSrc, DWORD bSrc,
2570                                        XImage *bmpImage,
2571                                        DWORD linebytes)
2572 {
2573     DWORD x;
2574     int h, width = min(srcwidth, dstwidth);
2575     const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_dst_byteswap;
2576
2577     if (lines < 0 )
2578     {
2579        lines = -lines;
2580        srcbits = srcbits + ( linebytes * (lines-1) );
2581        linebytes = -linebytes;
2582     }
2583
2584     switch (bmpImage->depth)
2585     {
2586     case 24:
2587         if (bmpImage->bits_per_pixel==24) {
2588             char* dstbits;
2589
2590             srcbits=srcbits+left*4;
2591             dstbits=bmpImage->data+left*3+(lines-1)*bmpImage->bytes_per_line;
2592
2593             if (rSrc==bmpImage->red_mask && gSrc==bmpImage->green_mask && bSrc==bmpImage->blue_mask) {
2594                 /* ==== rgb 0888 dib -> rgb 888 bmp ==== */
2595                 /* ==== bgr 0888 dib -> bgr 888 bmp ==== */
2596                 convs->Convert_0888_to_888_asis
2597                     (width,lines,
2598                      srcbits,linebytes,
2599                      dstbits,-bmpImage->bytes_per_line);
2600             } else if (bmpImage->green_mask!=0x00ff00 ||
2601                        (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2602                 goto notsupported;
2603                 /* the tests below assume sane bmpImage masks */
2604             } else if (rSrc==bmpImage->blue_mask && gSrc==bmpImage->green_mask && bSrc==bmpImage->red_mask) {
2605                 /* ==== rgb 0888 dib -> bgr 888 bmp ==== */
2606                 /* ==== bgr 0888 dib -> rgb 888 bmp ==== */
2607                 convs->Convert_0888_to_888_reverse
2608                     (width,lines,
2609                      srcbits,linebytes,
2610                      dstbits,-bmpImage->bytes_per_line);
2611             } else if (bmpImage->blue_mask==0xff) {
2612                 /* ==== any 0888 dib -> rgb 888 bmp ==== */
2613                 convs->Convert_any0888_to_rgb888
2614                     (width,lines,
2615                      srcbits,linebytes,
2616                      rSrc,gSrc,bSrc,
2617                      dstbits,-bmpImage->bytes_per_line);
2618             } else {
2619                 /* ==== any 0888 dib -> bgr 888 bmp ==== */
2620                 convs->Convert_any0888_to_bgr888
2621                     (width,lines,
2622                      srcbits,linebytes,
2623                      rSrc,gSrc,bSrc,
2624                      dstbits,-bmpImage->bytes_per_line);
2625             }
2626             break;
2627         }
2628         /* fall through */
2629
2630     case 32:
2631         {
2632             char* dstbits;
2633
2634             srcbits=srcbits+left*4;
2635             dstbits=bmpImage->data+left*4+(lines-1)*bmpImage->bytes_per_line;
2636
2637             if (gSrc==bmpImage->green_mask) {
2638                 if (rSrc==bmpImage->red_mask && bSrc==bmpImage->blue_mask) {
2639                     /* ==== rgb 0888 dib -> rgb 0888 bmp ==== */
2640                     /* ==== bgr 0888 dib -> bgr 0888 bmp ==== */
2641                     convs->Convert_0888_asis
2642                         (width,lines,
2643                          srcbits,linebytes,
2644                          dstbits,-bmpImage->bytes_per_line);
2645                 } else if (bmpImage->green_mask!=0x00ff00 ||
2646                            (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2647                     goto notsupported;
2648                     /* the tests below assume sane bmpImage masks */
2649                 } else if (rSrc==bmpImage->blue_mask && bSrc==bmpImage->red_mask) {
2650                     /* ==== rgb 0888 dib -> bgr 0888 bmp ==== */
2651                     /* ==== bgr 0888 dib -> rgb 0888 bmp ==== */
2652                     convs->Convert_0888_reverse
2653                         (width,lines,
2654                          srcbits,linebytes,
2655                          dstbits,-bmpImage->bytes_per_line);
2656                 } else {
2657                     /* ==== any 0888 dib -> any 0888 bmp ==== */
2658                     convs->Convert_0888_any
2659                         (width,lines,
2660                          srcbits,linebytes,
2661                          rSrc,gSrc,bSrc,
2662                          dstbits,-bmpImage->bytes_per_line,
2663                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
2664                 }
2665             } else if (bmpImage->green_mask!=0x00ff00 ||
2666                        (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2667                 goto notsupported;
2668                 /* the tests below assume sane bmpImage masks */
2669             } else {
2670                 /* ==== any 0888 dib -> any 0888 bmp ==== */
2671                 convs->Convert_0888_any
2672                     (width,lines,
2673                      srcbits,linebytes,
2674                      rSrc,gSrc,bSrc,
2675                      dstbits,-bmpImage->bytes_per_line,
2676                      bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
2677             }
2678         }
2679         break;
2680
2681     case 15:
2682     case 16:
2683         {
2684             char* dstbits;
2685
2686             srcbits=srcbits+left*4;
2687             dstbits=bmpImage->data+left*2+(lines-1)*bmpImage->bytes_per_line;
2688
2689             if (rSrc==0xff0000 && gSrc==0x00ff00 && bSrc==0x0000ff) {
2690                 if (bmpImage->green_mask==0x03e0) {
2691                     if (bmpImage->red_mask==0x7f00) {
2692                         /* ==== rgb 0888 dib -> rgb 555 bmp ==== */
2693                         convs->Convert_0888_to_555_asis
2694                             (width,lines,
2695                              srcbits,linebytes,
2696                              dstbits,-bmpImage->bytes_per_line);
2697                     } else if (bmpImage->blue_mask==0x7f00) {
2698                         /* ==== rgb 0888 dib -> bgr 555 bmp ==== */
2699                         convs->Convert_0888_to_555_reverse
2700                             (width,lines,
2701                              srcbits,linebytes,
2702                              dstbits,-bmpImage->bytes_per_line);
2703                     } else {
2704                         goto notsupported;
2705                     }
2706                 } else if (bmpImage->green_mask==0x07e0) {
2707                     if (bmpImage->red_mask==0xf800) {
2708                         /* ==== rgb 0888 dib -> rgb 565 bmp ==== */
2709                         convs->Convert_0888_to_565_asis
2710                             (width,lines,
2711                              srcbits,linebytes,
2712                              dstbits,-bmpImage->bytes_per_line);
2713                     } else if (bmpImage->blue_mask==0xf800) {
2714                         /* ==== rgb 0888 dib -> bgr 565 bmp ==== */
2715                         convs->Convert_0888_to_565_reverse
2716                             (width,lines,
2717                              srcbits,linebytes,
2718                              dstbits,-bmpImage->bytes_per_line);
2719                     } else {
2720                         goto notsupported;
2721                     }
2722                 } else {
2723                     goto notsupported;
2724                 }
2725             } else if (rSrc==0x0000ff && gSrc==0x00ff00 && bSrc==0xff0000) {
2726                 if (bmpImage->green_mask==0x03e0) {
2727                     if (bmpImage->blue_mask==0x7f00) {
2728                         /* ==== bgr 0888 dib -> bgr 555 bmp ==== */
2729                         convs->Convert_0888_to_555_asis
2730                             (width,lines,
2731                              srcbits,linebytes,
2732                              dstbits,-bmpImage->bytes_per_line);
2733                     } else if (bmpImage->red_mask==0x7f00) {
2734                         /* ==== bgr 0888 dib -> rgb 555 bmp ==== */
2735                         convs->Convert_0888_to_555_reverse
2736                             (width,lines,
2737                              srcbits,linebytes,
2738                              dstbits,-bmpImage->bytes_per_line);
2739                     } else {
2740                         goto notsupported;
2741                     }
2742                 } else if (bmpImage->green_mask==0x07e0) {
2743                     if (bmpImage->blue_mask==0xf800) {
2744                         /* ==== bgr 0888 dib -> bgr 565 bmp ==== */
2745                         convs->Convert_0888_to_565_asis
2746                             (width,lines,
2747                              srcbits,linebytes,
2748                              dstbits,-bmpImage->bytes_per_line);
2749                     } else if (bmpImage->red_mask==0xf800) {
2750                         /* ==== bgr 0888 dib -> rgb 565 bmp ==== */
2751                         convs->Convert_0888_to_565_reverse
2752                             (width,lines,
2753                              srcbits,linebytes,
2754                              dstbits,-bmpImage->bytes_per_line);
2755                     } else {
2756                         goto notsupported;
2757                     }
2758                 } else {
2759                     goto notsupported;
2760                 }
2761             } else {
2762                 if (bmpImage->green_mask==0x03e0 &&
2763                     (bmpImage->red_mask==0x7f00 ||
2764                      bmpImage->blue_mask==0x7f00)) {
2765                     /* ==== any 0888 dib -> rgb or bgr 555 bmp ==== */
2766                     convs->Convert_any0888_to_5x5
2767                         (width,lines,
2768                          srcbits,linebytes,
2769                          rSrc,gSrc,bSrc,
2770                          dstbits,-bmpImage->bytes_per_line,
2771                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
2772                 } else if (bmpImage->green_mask==0x07e0 &&
2773                            (bmpImage->red_mask==0xf800 ||
2774                             bmpImage->blue_mask==0xf800)) {
2775                     /* ==== any 0888 dib -> rgb or bgr 565 bmp ==== */
2776                     convs->Convert_any0888_to_5x5
2777                         (width,lines,
2778                          srcbits,linebytes,
2779                          rSrc,gSrc,bSrc,
2780                          dstbits,-bmpImage->bytes_per_line,
2781                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
2782                 } else {
2783                     goto notsupported;
2784                 }
2785             }
2786         }
2787         break;
2788
2789     default:
2790     notsupported:
2791         WARN("from 32 bit DIB (%x,%x,%x) to unknown %d bit bitmap (%lx,%lx,%lx)\n",
2792               rSrc, gSrc, bSrc, bmpImage->bits_per_pixel, bmpImage->red_mask,
2793               bmpImage->green_mask, bmpImage->blue_mask );
2794         /* fall through */
2795     case 1:
2796     case 4:
2797     case 8:
2798         {
2799             /* ==== any 0888 dib -> pal 1, 4 or 8 bmp ==== */
2800             const DWORD* srcpixel;
2801             int rShift,gShift,bShift;
2802
2803             rShift=X11DRV_DIB_MaskToShift(rSrc);
2804             gShift=X11DRV_DIB_MaskToShift(gSrc);
2805             bShift=X11DRV_DIB_MaskToShift(bSrc);
2806             srcbits+=left*4;
2807             for (h = lines - 1; h >= 0; h--) {
2808                 srcpixel=(const DWORD*)srcbits;
2809                 for (x = left; x < width+left; x++) {
2810                     DWORD srcvalue;
2811                     BYTE red,green,blue;
2812                     srcvalue=*srcpixel++;
2813                     red=  (srcvalue >> rShift) & 0xff;
2814                     green=(srcvalue >> gShift) & 0xff;
2815                     blue= (srcvalue >> bShift) & 0xff;
2816                     XPutPixel(bmpImage, x, h, X11DRV_PALETTE_ToPhysical
2817                               (physDev, RGB(red,green,blue)));
2818                 }
2819                 srcbits += linebytes;
2820             }
2821         }
2822         break;
2823     }
2824
2825 }
2826
2827 /***********************************************************************
2828  *           X11DRV_DIB_GetImageBits_32
2829  *
2830  * GetDIBits for an 32-bit deep DIB.
2831  */
2832 static void X11DRV_DIB_GetImageBits_32( X11DRV_PDEVICE *physDev, int lines, BYTE *dstbits,
2833                                         DWORD dstwidth, DWORD srcwidth,
2834                                         PALETTEENTRY *srccolors,
2835                                         DWORD rDst, DWORD gDst, DWORD bDst,
2836                                         XImage *bmpImage, int linebytes )
2837 {
2838     DWORD x;
2839     int h, width = min(srcwidth, dstwidth);
2840     const dib_conversions *convs = (bmpImage->byte_order == LSBFirst) ? &dib_normal : &dib_src_byteswap;
2841
2842     if (lines < 0 )
2843     {
2844         lines = -lines;
2845         dstbits = dstbits + ( linebytes * (lines-1) );
2846         linebytes = -linebytes;
2847     }
2848
2849     switch (bmpImage->depth)
2850     {
2851     case 24:
2852         if (bmpImage->bits_per_pixel==24) {
2853             const void* srcbits;
2854
2855             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2856
2857             if (rDst==bmpImage->red_mask && gDst==bmpImage->green_mask && bDst==bmpImage->blue_mask) {
2858                 /* ==== rgb 888 bmp -> rgb 0888 dib ==== */
2859                 /* ==== bgr 888 bmp -> bgr 0888 dib ==== */
2860                 convs->Convert_888_to_0888_asis
2861                     (width,lines,
2862                      srcbits,-bmpImage->bytes_per_line,
2863                      dstbits,linebytes);
2864             } else if (bmpImage->green_mask!=0x00ff00 ||
2865                        (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2866                 goto notsupported;
2867                 /* the tests below assume sane bmpImage masks */
2868             } else if (rDst==bmpImage->blue_mask && gDst==bmpImage->green_mask && bDst==bmpImage->red_mask) {
2869                 /* ==== rgb 888 bmp -> bgr 0888 dib ==== */
2870                 /* ==== bgr 888 bmp -> rgb 0888 dib ==== */
2871                 convs->Convert_888_to_0888_reverse
2872                     (width,lines,
2873                      srcbits,-bmpImage->bytes_per_line,
2874                      dstbits,linebytes);
2875             } else if (bmpImage->blue_mask==0xff) {
2876                 /* ==== rgb 888 bmp -> any 0888 dib ==== */
2877                 convs->Convert_rgb888_to_any0888
2878                     (width,lines,
2879                      srcbits,-bmpImage->bytes_per_line,
2880                      dstbits,linebytes,
2881                      rDst,gDst,bDst);
2882             } else {
2883                 /* ==== bgr 888 bmp -> any 0888 dib ==== */
2884                 convs->Convert_bgr888_to_any0888
2885                     (width,lines,
2886                      srcbits,-bmpImage->bytes_per_line,
2887                      dstbits,linebytes,
2888                      rDst,gDst,bDst);
2889             }
2890             break;
2891         }
2892         /* fall through */
2893
2894     case 32:
2895         {
2896             const char* srcbits;
2897
2898             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2899
2900             if (gDst==bmpImage->green_mask) {
2901                 if (rDst==bmpImage->red_mask && bDst==bmpImage->blue_mask) {
2902                     /* ==== rgb 0888 bmp -> rgb 0888 dib ==== */
2903                     /* ==== bgr 0888 bmp -> bgr 0888 dib ==== */
2904                     convs->Convert_0888_asis
2905                         (width,lines,
2906                          srcbits,-bmpImage->bytes_per_line,
2907                          dstbits,linebytes);
2908                 } else if (bmpImage->green_mask!=0x00ff00 ||
2909                            (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2910                     goto notsupported;
2911                     /* the tests below assume sane bmpImage masks */
2912                 } else if (rDst==bmpImage->blue_mask && bDst==bmpImage->red_mask) {
2913                     /* ==== rgb 0888 bmp -> bgr 0888 dib ==== */
2914                     /* ==== bgr 0888 bmp -> rgb 0888 dib ==== */
2915                     convs->Convert_0888_reverse
2916                         (width,lines,
2917                          srcbits,-bmpImage->bytes_per_line,
2918                          dstbits,linebytes);
2919                 } else {
2920                     /* ==== any 0888 bmp -> any 0888 dib ==== */
2921                     convs->Convert_0888_any
2922                         (width,lines,
2923                          srcbits,-bmpImage->bytes_per_line,
2924                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask,
2925                          dstbits,linebytes,
2926                          rDst,gDst,bDst);
2927                 }
2928             } else if (bmpImage->green_mask!=0x00ff00 ||
2929                        (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2930                 goto notsupported;
2931                 /* the tests below assume sane bmpImage masks */
2932             } else {
2933                 /* ==== any 0888 bmp -> any 0888 dib ==== */
2934                 convs->Convert_0888_any
2935                     (width,lines,
2936                      srcbits,-bmpImage->bytes_per_line,
2937                      bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask,
2938                      dstbits,linebytes,
2939                      rDst,gDst,bDst);
2940             }
2941         }
2942         break;
2943
2944     case 15:
2945     case 16:
2946         {
2947             const char* srcbits;
2948
2949             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2950
2951             if (rDst==0xff0000 && gDst==0x00ff00 && bDst==0x0000ff) {
2952                 if (bmpImage->green_mask==0x03e0) {
2953                     if (bmpImage->red_mask==0x7f00) {
2954                         /* ==== rgb 555 bmp -> rgb 0888 dib ==== */
2955                         convs->Convert_555_to_0888_asis
2956                             (width,lines,
2957                              srcbits,-bmpImage->bytes_per_line,
2958                              dstbits,linebytes);
2959                     } else if (bmpImage->blue_mask==0x7f00) {
2960                         /* ==== bgr 555 bmp -> rgb 0888 dib ==== */
2961                         convs->Convert_555_to_0888_reverse
2962                             (width,lines,
2963                              srcbits,-bmpImage->bytes_per_line,
2964                              dstbits,linebytes);
2965                     } else {
2966                         goto notsupported;
2967                     }
2968                 } else if (bmpImage->green_mask==0x07e0) {
2969                     if (bmpImage->red_mask==0xf800) {
2970                         /* ==== rgb 565 bmp -> rgb 0888 dib ==== */
2971                         convs->Convert_565_to_0888_asis
2972                             (width,lines,
2973                              srcbits,-bmpImage->bytes_per_line,
2974                              dstbits,linebytes);
2975                     } else if (bmpImage->blue_mask==0xf800) {
2976                         /* ==== bgr 565 bmp -> rgb 0888 dib ==== */
2977                         convs->Convert_565_to_0888_reverse
2978                             (width,lines,
2979                              srcbits,-bmpImage->bytes_per_line,
2980                              dstbits,linebytes);
2981                     } else {
2982                         goto notsupported;
2983                     }
2984                 } else {
2985                     goto notsupported;
2986                 }
2987             } else if (rDst==0x0000ff && gDst==0x00ff00 && bDst==0xff0000) {
2988                 if (bmpImage->green_mask==0x03e0) {
2989                     if (bmpImage->blue_mask==0x7f00) {
2990                         /* ==== bgr 555 bmp -> bgr 0888 dib ==== */
2991                         convs->Convert_555_to_0888_asis
2992                             (width,lines,
2993                              srcbits,-bmpImage->bytes_per_line,
2994                              dstbits,linebytes);
2995                     } else if (bmpImage->red_mask==0x7f00) {
2996                         /* ==== rgb 555 bmp -> bgr 0888 dib ==== */
2997                         convs->Convert_555_to_0888_reverse
2998                             (width,lines,
2999                              srcbits,-bmpImage->bytes_per_line,
3000                              dstbits,linebytes);
3001                     } else {
3002                         goto notsupported;
3003                     }
3004                 } else if (bmpImage->green_mask==0x07e0) {
3005                     if (bmpImage->blue_mask==0xf800) {
3006                         /* ==== bgr 565 bmp -> bgr 0888 dib ==== */
3007                         convs->Convert_565_to_0888_asis
3008                             (width,lines,
3009                              srcbits,-bmpImage->bytes_per_line,
3010                              dstbits,linebytes);
3011                     } else if (bmpImage->red_mask==0xf800) {
3012                         /* ==== rgb 565 bmp -> bgr 0888 dib ==== */
3013                         convs->Convert_565_to_0888_reverse
3014                             (width,lines,
3015                              srcbits,-bmpImage->bytes_per_line,
3016                              dstbits,linebytes);
3017                     } else {
3018                         goto notsupported;
3019                     }
3020                 } else {
3021                     goto notsupported;
3022                 }
3023             } else {
3024                 if (bmpImage->green_mask==0x03e0 &&
3025                     (bmpImage->red_mask==0x7f00 ||
3026                      bmpImage->blue_mask==0x7f00)) {
3027                     /* ==== rgb or bgr 555 bmp -> any 0888 dib ==== */
3028                     convs->Convert_5x5_to_any0888
3029                         (width,lines,
3030                          srcbits,-bmpImage->bytes_per_line,
3031                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask,
3032                          dstbits,linebytes,
3033                          rDst,gDst,bDst);
3034                 } else if (bmpImage->green_mask==0x07e0 &&
3035                            (bmpImage->red_mask==0xf800 ||
3036                             bmpImage->blue_mask==0xf800)) {
3037                     /* ==== rgb or bgr 565 bmp -> any 0888 dib ==== */
3038                     convs->Convert_5x5_to_any0888
3039                         (width,lines,
3040                          srcbits,-bmpImage->bytes_per_line,
3041                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask,
3042                          dstbits,linebytes,
3043                          rDst,gDst,bDst);
3044                 } else {
3045                     goto notsupported;
3046                 }
3047             }
3048         }
3049         break;
3050
3051     case 1:
3052     case 4:
3053         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
3054             && srccolors) {
3055             /* ==== pal 1 or 4 bmp -> any 0888 dib ==== */
3056             int rShift,gShift,bShift;
3057             DWORD* dstpixel;
3058
3059             rShift=X11DRV_DIB_MaskToShift(rDst);
3060             gShift=X11DRV_DIB_MaskToShift(gDst);
3061             bShift=X11DRV_DIB_MaskToShift(bDst);
3062             for (h = lines - 1; h >= 0; h--) {
3063                 dstpixel=(DWORD*)dstbits;
3064                 for (x = 0; x < width; x++) {
3065                     PALETTEENTRY srcval;
3066                     srcval = srccolors[XGetPixel(bmpImage, x, h)];
3067                     *dstpixel++=(srcval.peRed   << rShift) |
3068                                 (srcval.peGreen << gShift) |
3069                                 (srcval.peBlue  << bShift);
3070                 }
3071                 dstbits += linebytes;
3072             }
3073         } else {
3074             goto notsupported;
3075         }
3076         break;
3077
3078     case 8:
3079         if (X11DRV_DIB_CheckMask(bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask)
3080             && srccolors) {
3081             /* ==== pal 8 bmp -> any 0888 dib ==== */
3082             int rShift,gShift,bShift;
3083             const void* srcbits;
3084             const BYTE* srcpixel;
3085             DWORD* dstpixel;
3086
3087             rShift=X11DRV_DIB_MaskToShift(rDst);
3088             gShift=X11DRV_DIB_MaskToShift(gDst);
3089             bShift=X11DRV_DIB_MaskToShift(bDst);
3090             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3091             for (h = lines - 1; h >= 0; h--) {
3092                 srcpixel=srcbits;
3093                 dstpixel=(DWORD*)dstbits;
3094                 for (x = 0; x < width; x++) {
3095                     PALETTEENTRY srcval;
3096                     srcval=srccolors[*srcpixel++];
3097                     *dstpixel++=(srcval.peRed   << rShift) |
3098                                 (srcval.peGreen << gShift) |
3099                                 (srcval.peBlue  << bShift);
3100                 }
3101                 srcbits = (const char*)srcbits - bmpImage->bytes_per_line;
3102                 dstbits += linebytes;
3103             }
3104         } else {
3105             goto notsupported;
3106         }
3107         break;
3108
3109     default:
3110     notsupported:
3111         {
3112             /* ==== any bmp format -> any 0888 dib ==== */
3113             int rShift,gShift,bShift;
3114             DWORD* dstpixel;
3115
3116             WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 32 bit DIB (%x,%x,%x)\n",
3117                   bmpImage->depth, bmpImage->red_mask,
3118                   bmpImage->green_mask, bmpImage->blue_mask,
3119                   rDst,gDst,bDst);
3120
3121             rShift=X11DRV_DIB_MaskToShift(rDst);
3122             gShift=X11DRV_DIB_MaskToShift(gDst);
3123             bShift=X11DRV_DIB_MaskToShift(bDst);
3124             for (h = lines - 1; h >= 0; h--) {
3125                 dstpixel=(DWORD*)dstbits;
3126                 for (x = 0; x < width; x++) {
3127                     COLORREF srcval;
3128                     srcval=X11DRV_PALETTE_ToLogical(physDev, XGetPixel(bmpImage, x, h));
3129                     *dstpixel++=(GetRValue(srcval) << rShift) |
3130                                 (GetGValue(srcval) << gShift) |
3131                                 (GetBValue(srcval) << bShift);
3132                 }
3133                 dstbits += linebytes;
3134             }
3135         }
3136         break;
3137     }
3138 }
3139
3140 /***********************************************************************
3141  *           X11DRV_DIB_SetImageBits
3142  *
3143  * Transfer the bits to an X image.
3144  * Helper function for SetDIBits() and SetDIBitsToDevice().
3145  */
3146 static int X11DRV_DIB_SetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
3147 {
3148     int lines = descr->lines >= 0 ? descr->lines : -descr->lines;
3149     void *old_data = NULL;
3150     XImage *bmpImage;
3151
3152     wine_tsx11_lock();
3153     if (descr->image)
3154         bmpImage = descr->image;
3155     else {
3156         bmpImage = XCreateImage( gdi_display, visual, descr->depth, ZPixmap, 0, NULL,
3157                                  descr->infoWidth, lines, 32, 0 );
3158         bmpImage->data = HeapAlloc( GetProcessHeap(), 0, lines * bmpImage->bytes_per_line );
3159         if(bmpImage->data == NULL) {
3160             ERR("Out of memory!\n");
3161             XDestroyImage( bmpImage );
3162             wine_tsx11_unlock();
3163             return 0;
3164         }
3165         if (descr->shifts)
3166         {
3167             bmpImage->red_mask = descr->shifts->physicalRed.max << descr->shifts->physicalRed.shift;
3168             bmpImage->green_mask = descr->shifts->physicalGreen.max << descr->shifts->physicalGreen.shift;
3169             bmpImage->blue_mask = descr->shifts->physicalBlue.max << descr->shifts->physicalBlue.shift;
3170         }
3171     }
3172     wine_tsx11_unlock();
3173
3174     TRACE("Dib: depth=%d r=%x g=%x b=%x\n",
3175           descr->infoBpp,descr->rMask,descr->gMask,descr->bMask);
3176     TRACE("Bmp: depth=%d/%d r=%lx g=%lx b=%lx\n",
3177           bmpImage->depth,bmpImage->bits_per_pixel,
3178           bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
3179
3180 #ifdef HAVE_LIBXXSHM
3181     if (descr->shm_mode == X11DRV_SHM_PIXMAP
3182             && descr->xSrc == 0 && descr->ySrc == 0
3183             && descr->xDest == 0 && descr->yDest == 0)
3184     {
3185         TRACE("Using the shared pixmap data.\n");
3186
3187         wine_tsx11_lock();
3188         XSync( gdi_display, False );
3189         wine_tsx11_unlock();
3190
3191         old_data = descr->image->data;
3192         descr->image->data = descr->physBitmap->shminfo.shmaddr;
3193     }
3194 #endif
3195
3196       /* Transfer the pixels */
3197     __TRY
3198     {
3199         switch(descr->infoBpp)
3200         {
3201         case 1:
3202             X11DRV_DIB_SetImageBits_1( descr->lines, descr->bits, descr->infoWidth,
3203                                        descr->width, descr->xSrc, (int *)(descr->colorMap),
3204                                        bmpImage, descr->dibpitch );
3205             break;
3206         case 4:
3207             X11DRV_DIB_SetImageBits_4( descr->lines, descr->bits,
3208                                        descr->infoWidth, descr->width,
3209                                        descr->xSrc, (int*)(descr->colorMap),
3210                                        bmpImage, descr->dibpitch );
3211             break;
3212         case 8:
3213             X11DRV_DIB_SetImageBits_8( descr->lines, descr->bits,
3214                                        descr->infoWidth, descr->width,
3215                                        descr->xSrc, (int *)(descr->colorMap),
3216                                        bmpImage, descr->dibpitch );
3217             break;
3218         case 16:
3219             X11DRV_DIB_SetImageBits_16( descr->lines, descr->bits,
3220                                         descr->infoWidth, descr->width,
3221                                         descr->xSrc, descr->physDev,
3222                                         descr->rMask, descr->gMask, descr->bMask,
3223                                         bmpImage, descr->dibpitch);
3224             break;
3225         case 24:
3226             X11DRV_DIB_SetImageBits_24( descr->lines, descr->bits,
3227                                         descr->infoWidth, descr->width,
3228                                         descr->xSrc, descr->physDev,
3229                                         descr->rMask, descr->gMask, descr->bMask,
3230                                         bmpImage, descr->dibpitch);
3231             break;
3232         case 32:
3233             X11DRV_DIB_SetImageBits_32( descr->lines, descr->bits,
3234                                         descr->infoWidth, descr->width,
3235                                         descr->xSrc, descr->physDev,
3236                                         descr->rMask, descr->gMask, descr->bMask,
3237                                         bmpImage, descr->dibpitch);
3238             break;
3239         default:
3240             WARN("(%d): Invalid depth\n", descr->infoBpp );
3241             break;
3242         }
3243     }
3244     __EXCEPT_PAGE_FAULT
3245     {
3246         WARN( "invalid bits pointer %p\n", descr->bits );
3247         lines = 0;
3248     }
3249     __ENDTRY
3250
3251     TRACE("XPutImage(%ld,%p,%p,%d,%d,%d,%d,%d,%d)\n",
3252      descr->drawable, descr->gc, bmpImage,
3253      descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
3254      descr->width, descr->height);
3255
3256     wine_tsx11_lock();
3257     if (lines)
3258     {
3259 #ifdef HAVE_LIBXXSHM
3260         if (descr->shm_mode == X11DRV_SHM_PIXMAP
3261                 && descr->xSrc == 0 && descr->ySrc == 0
3262                 && descr->xDest == 0 && descr->yDest == 0)
3263         {
3264             XSync( gdi_display, False );
3265         }
3266         else if (descr->shm_mode == X11DRV_SHM_IMAGE && descr->image)
3267         {
3268             XShmPutImage( gdi_display, descr->drawable, descr->gc, bmpImage,
3269                           descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
3270                           descr->width, descr->height, FALSE );
3271             XSync( gdi_display, 0 );
3272         }
3273         else
3274 #endif
3275         {
3276             XPutImage( gdi_display, descr->drawable, descr->gc, bmpImage,
3277                        descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
3278                        descr->width, descr->height );
3279         }
3280     }
3281
3282     if (old_data) descr->image->data = old_data;
3283
3284     if (!descr->image) X11DRV_DIB_DestroyXImage( bmpImage );
3285     wine_tsx11_unlock();
3286     return lines;
3287 }
3288
3289 /***********************************************************************
3290  *           X11DRV_DIB_GetImageBits
3291  *
3292  * Transfer the bits from an X image.
3293  */
3294 static int X11DRV_DIB_GetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
3295 {
3296     int lines = descr->lines >= 0 ? descr->lines : -descr->lines;
3297     void *old_data = NULL;
3298     XImage *bmpImage;
3299
3300     wine_tsx11_lock();
3301    if (descr->image)
3302         bmpImage = descr->image;
3303     else {
3304         bmpImage = XCreateImage( gdi_display, visual, descr->depth, ZPixmap, 0, NULL,
3305                                  descr->infoWidth, lines, 32, 0 );
3306         bmpImage->data = HeapAlloc( GetProcessHeap(), 0, lines * bmpImage->bytes_per_line );
3307         if(bmpImage->data == NULL) {
3308             ERR("Out of memory!\n");
3309             XDestroyImage( bmpImage );
3310             wine_tsx11_unlock();
3311             return 0;
3312         }
3313         if (descr->shifts)
3314         {
3315             bmpImage->red_mask = descr->shifts->physicalRed.max << descr->shifts->physicalRed.shift;
3316             bmpImage->green_mask = descr->shifts->physicalGreen.max << descr->shifts->physicalGreen.shift;
3317             bmpImage->blue_mask = descr->shifts->physicalBlue.max << descr->shifts->physicalBlue.shift;
3318         }
3319     }
3320
3321 #ifdef HAVE_LIBXXSHM
3322
3323     /* We must not call XShmGetImage() with a bitmap which is bigger than the available area.
3324        If we do, XShmGetImage() will fail (X exception), as it checks for this internally. */
3325     if (descr->shm_mode == X11DRV_SHM_PIXMAP && descr->image
3326             && descr->xSrc == 0 && descr->ySrc == 0
3327             && descr->xDest == 0 && descr->yDest == 0
3328             && bmpImage->width <= (descr->width - descr->xSrc)
3329             && bmpImage->height <= (descr->height - descr->ySrc))
3330     {
3331         XSync( gdi_display, False );
3332         old_data = bmpImage->data;
3333         bmpImage->data = descr->physBitmap->shminfo.shmaddr;
3334         TRACE("Using shared pixmap data.\n");
3335     }
3336     else if (descr->shm_mode == X11DRV_SHM_IMAGE && descr->image
3337             && bmpImage->width <= (descr->width - descr->xSrc)
3338             && bmpImage->height <= (descr->height - descr->ySrc))
3339     {
3340         int saveRed, saveGreen, saveBlue;
3341
3342         TRACE("XShmGetImage(%p, %ld, %p, %d, %d, %ld)\n",
3343                             gdi_display, descr->drawable, bmpImage,
3344                             descr->xSrc, descr->ySrc, AllPlanes);
3345
3346         /* We must save and restore the bmpImage's masks in order
3347          * to preserve them across the call to XShmGetImage, which
3348          * decides to eliminate them since it doesn't happen to know
3349          * what the format of the image is supposed to be, even though
3350          * we do. */
3351         saveRed = bmpImage->red_mask;
3352         saveBlue= bmpImage->blue_mask;
3353         saveGreen = bmpImage->green_mask;
3354
3355         XShmGetImage( gdi_display, descr->drawable, bmpImage,
3356                       descr->xSrc, descr->ySrc, AllPlanes);
3357
3358         bmpImage->red_mask = saveRed;
3359         bmpImage->blue_mask = saveBlue;
3360         bmpImage->green_mask = saveGreen;
3361     }
3362     else
3363 #endif /* HAVE_LIBXXSHM */
3364     {
3365         TRACE("XGetSubImage(%p,%ld,%d,%d,%d,%d,%ld,%d,%p,%d,%d)\n",
3366               gdi_display, descr->drawable, descr->xSrc, descr->ySrc, descr->width,
3367               lines, AllPlanes, ZPixmap, bmpImage, descr->xDest, descr->yDest);
3368         XGetSubImage( gdi_display, descr->drawable, descr->xSrc, descr->ySrc,
3369                       descr->width, lines, AllPlanes, ZPixmap,
3370                       bmpImage, descr->xDest, descr->yDest );
3371     }
3372     wine_tsx11_unlock();
3373
3374     TRACE("Dib: depth=%2d r=%x g=%x b=%x\n",
3375           descr->infoBpp,descr->rMask,descr->gMask,descr->bMask);
3376     TRACE("Bmp: depth=%2d/%2d r=%lx g=%lx b=%lx\n",
3377           bmpImage->depth,bmpImage->bits_per_pixel,
3378           bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
3379       /* Transfer the pixels */
3380     switch(descr->infoBpp)
3381     {
3382     case 1:
3383           X11DRV_DIB_GetImageBits_1( descr->lines,(LPVOID)descr->bits,
3384                                      descr->infoWidth, descr->width,
3385                                      descr->colorMap, descr->palentry,
3386                                      bmpImage, descr->dibpitch );
3387        break;
3388
3389     case 4:
3390         X11DRV_DIB_GetImageBits_4( descr->lines,(LPVOID)descr->bits,
3391                                    descr->infoWidth, descr->width,
3392                                    descr->colorMap, descr->palentry,
3393                                    bmpImage, descr->dibpitch );
3394         break;
3395     case 8:
3396         X11DRV_DIB_GetImageBits_8( descr->lines, (LPVOID)descr->bits,
3397                                    descr->infoWidth, descr->width,
3398                                    descr->colorMap, descr->palentry,
3399                                    bmpImage, descr->dibpitch );
3400         break;
3401     case 16:
3402        X11DRV_DIB_GetImageBits_16( descr->physDev, descr->lines, (LPVOID)descr->bits,
3403                                    descr->infoWidth,descr->width,
3404                                    descr->palentry,
3405                                    descr->rMask, descr->gMask, descr->bMask,
3406                                    bmpImage, descr->dibpitch );
3407        break;
3408
3409     case 24:
3410        X11DRV_DIB_GetImageBits_24( descr->physDev, descr->lines, (LPVOID)descr->bits,
3411                                    descr->infoWidth,descr->width,
3412                                    descr->palentry,
3413                                    descr->rMask, descr->gMask, descr->bMask,
3414                                    bmpImage, descr->dibpitch);
3415        break;
3416
3417     case 32:
3418        X11DRV_DIB_GetImageBits_32( descr->physDev, descr->lines, (LPVOID)descr->bits,
3419                                    descr->infoWidth, descr->width,
3420                                    descr->palentry,
3421                                    descr->rMask, descr->gMask, descr->bMask,
3422                                    bmpImage, descr->dibpitch);
3423        break;
3424
3425     default:
3426         WARN("(%d): Invalid depth\n", descr->infoBpp );
3427         break;
3428     }
3429
3430     if (old_data) bmpImage->data = old_data;
3431     if (!descr->image) X11DRV_DIB_DestroyXImage( bmpImage );
3432     return lines;
3433 }
3434
3435 /***********************************************************************
3436  *           X11DRV_DIB_DoCopyDIBSection
3437  */
3438 static void X11DRV_DIB_DoCopyDIBSection(X_PHYSBITMAP *physBitmap, BOOL toDIB,
3439                                         void *colorMap, int nColorMap,
3440                                         Drawable dest, GC gc,
3441                                         DWORD xSrc, DWORD ySrc,
3442                                         DWORD xDest, DWORD yDest,
3443                                         DWORD width, DWORD height)
3444 {
3445   DIBSECTION dibSection;
3446   X11DRV_DIB_IMAGEBITS_DESCR descr;
3447   int identity[2] = {0,1};
3448
3449   if (!GetObjectW( physBitmap->hbitmap, sizeof(dibSection), &dibSection )) return;
3450
3451   descr.physDev     = NULL;
3452   descr.palentry    = NULL;
3453   descr.infoWidth   = dibSection.dsBmih.biWidth;
3454   descr.infoBpp     = dibSection.dsBmih.biBitCount;
3455   descr.lines       = physBitmap->topdown ? -dibSection.dsBmih.biHeight : dibSection.dsBmih.biHeight;
3456   descr.image       = physBitmap->image;
3457   descr.colorMap    = colorMap;
3458   descr.nColorMap   = nColorMap;
3459   descr.bits        = dibSection.dsBm.bmBits;
3460   descr.depth       = physBitmap->depth;
3461   descr.shifts      = physBitmap->trueColor ? &physBitmap->color_shifts : NULL;
3462   descr.compression = dibSection.dsBmih.biCompression;
3463   descr.physBitmap  = physBitmap;
3464
3465   if(descr.infoBpp == 1)
3466       descr.colorMap = (void*)identity;
3467
3468   switch (descr.infoBpp)
3469   {
3470     case 1:
3471     case 4:
3472     case 8:
3473       descr.rMask = descr.gMask = descr.bMask = 0;
3474       break;
3475     case 15:
3476     case 16:
3477       descr.rMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[0] : 0x7c00;
3478       descr.gMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[1] : 0x03e0;
3479       descr.bMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[2] : 0x001f;
3480       break;
3481
3482     case 24:
3483     case 32:
3484       descr.rMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[0] : 0xff0000;
3485       descr.gMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[1] : 0x00ff00;
3486       descr.bMask = (descr.compression == BI_BITFIELDS) ? dibSection.dsBitfields[2] : 0x0000ff;
3487       break;
3488   }
3489
3490   /* Hack for now */
3491   descr.drawable  = dest;
3492   descr.gc        = gc;
3493   descr.xSrc      = xSrc;
3494   descr.ySrc      = ySrc;
3495   descr.xDest     = xDest;
3496   descr.yDest     = yDest;
3497   descr.width     = width;
3498   descr.height    = height;
3499   descr.sizeImage = 0;
3500
3501   descr.shm_mode = physBitmap->shm_mode;
3502 #ifdef HAVE_LIBXXSHM
3503   if (physBitmap->shm_mode == X11DRV_SHM_PIXMAP && physBitmap->pixmap != dest)
3504   {
3505     descr.shm_mode = X11DRV_SHM_NONE;
3506   }
3507 #endif
3508   descr.dibpitch = dibSection.dsBm.bmWidthBytes;
3509
3510   if (toDIB)
3511     {
3512       TRACE("Copying from Pixmap to DIB bits\n");
3513       X11DRV_DIB_GetImageBits( &descr );
3514     }
3515   else
3516     {
3517       TRACE("Copying from DIB bits to Pixmap\n");
3518       X11DRV_DIB_SetImageBits( &descr );
3519     }
3520 }
3521
3522 /***********************************************************************
3523  *           X11DRV_DIB_DoUpdateDIBSection
3524  */
3525 static void X11DRV_DIB_DoUpdateDIBSection(X_PHYSBITMAP *physBitmap, BOOL toDIB)
3526 {
3527     BITMAP bitmap;
3528
3529     GetObjectW( physBitmap->hbitmap, sizeof(bitmap), &bitmap );
3530     X11DRV_DIB_DoCopyDIBSection(physBitmap, toDIB,
3531                                 physBitmap->colorMap, physBitmap->nColorMap,
3532                                 physBitmap->pixmap, get_bitmap_gc(physBitmap->depth),
3533                                 0, 0, 0, 0, bitmap.bmWidth, bitmap.bmHeight);
3534 }
3535
3536 /***********************************************************************
3537  *           X11DRV_DIB_FaultHandler
3538  */
3539 static LONG CALLBACK X11DRV_DIB_FaultHandler( PEXCEPTION_POINTERS ep )
3540 {
3541     X_PHYSBITMAP *physBitmap = NULL;
3542     BOOL found = FALSE;
3543     BYTE *addr;
3544     struct list *ptr;
3545     const size_t pagemask = getpagesize() - 1;
3546
3547     if (ep->ExceptionRecord->ExceptionCode != EXCEPTION_ACCESS_VIOLATION)
3548         return EXCEPTION_CONTINUE_SEARCH;
3549
3550     addr = (BYTE *)ep->ExceptionRecord->ExceptionInformation[1];
3551
3552     EnterCriticalSection(&dibs_cs);
3553     LIST_FOR_EACH( ptr, &dibs_list )
3554     {
3555         physBitmap = LIST_ENTRY( ptr, X_PHYSBITMAP, entry );
3556         if ((physBitmap->base <= addr) &&
3557             (addr < physBitmap->base + ((physBitmap->size + pagemask) & ~pagemask)))
3558         {
3559             found = TRUE;
3560             break;
3561         }
3562     }
3563     LeaveCriticalSection(&dibs_cs);
3564
3565     if (!found) return EXCEPTION_CONTINUE_SEARCH;
3566
3567     if (addr >= physBitmap->base + physBitmap->size)
3568         WARN( "%p: access to %p beyond the end of the DIB\n", physBitmap->hbitmap, addr );
3569
3570     X11DRV_DIB_Lock( physBitmap, DIB_Status_None );
3571     if (ep->ExceptionRecord->ExceptionInformation[0] == EXCEPTION_WRITE_FAULT) {
3572         /* the app tried to write the DIB bits */
3573         X11DRV_DIB_Coerce( physBitmap, DIB_Status_AppMod);
3574     } else {
3575         /* the app tried to read the DIB bits */
3576         X11DRV_DIB_Coerce( physBitmap, DIB_Status_InSync);
3577     }
3578     X11DRV_DIB_Unlock( physBitmap, TRUE );
3579
3580     return EXCEPTION_CONTINUE_EXECUTION;
3581 }
3582
3583 /***********************************************************************
3584  *           X11DRV_DIB_Coerce
3585  */
3586 static INT X11DRV_DIB_Coerce(X_PHYSBITMAP *physBitmap, INT req)
3587 {
3588     INT ret = DIB_Status_None;
3589
3590     if (!physBitmap->image) return ret;  /* not a DIB section */
3591     EnterCriticalSection(&physBitmap->lock);
3592     ret = physBitmap->status;
3593     switch (req) {
3594     case DIB_Status_GdiMod:
3595       /* GDI access - request to draw on pixmap */
3596       switch (physBitmap->status)
3597       {
3598         default:
3599         case DIB_Status_None:
3600           physBitmap->p_status = DIB_Status_GdiMod;
3601           X11DRV_DIB_DoUpdateDIBSection( physBitmap, FALSE );
3602           break;
3603
3604         case DIB_Status_GdiMod:
3605           TRACE("GdiMod requested in status GdiMod\n" );
3606           physBitmap->p_status = DIB_Status_GdiMod;
3607           break;
3608
3609         case DIB_Status_InSync:
3610           TRACE("GdiMod requested in status InSync\n" );
3611           X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_NOACCESS );
3612           physBitmap->status = DIB_Status_GdiMod;
3613           physBitmap->p_status = DIB_Status_InSync;
3614           break;
3615
3616         case DIB_Status_AppMod:
3617           TRACE("GdiMod requested in status AppMod\n" );
3618           /* make it readonly to avoid app changing data while we copy */
3619           X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READONLY );
3620           X11DRV_DIB_DoUpdateDIBSection( physBitmap, FALSE );
3621           X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_NOACCESS );
3622           physBitmap->p_status = DIB_Status_AppMod;
3623           physBitmap->status = DIB_Status_GdiMod;
3624           break;
3625       }
3626       break;
3627
3628     case DIB_Status_InSync:
3629       /* App access - request access to read DIB surface */
3630       /* (typically called from signal handler) */
3631       switch (physBitmap->status)
3632       {
3633         default:
3634         case DIB_Status_None:
3635           /* shouldn't happen from signal handler */
3636           break;
3637
3638         case DIB_Status_GdiMod:
3639           TRACE("InSync requested in status GdiMod\n" );
3640           X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
3641           X11DRV_DIB_DoUpdateDIBSection( physBitmap, TRUE );
3642           X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READONLY );
3643           physBitmap->status = DIB_Status_InSync;
3644           break;
3645
3646         case DIB_Status_InSync:
3647           TRACE("InSync requested in status InSync\n" );
3648           /* shouldn't happen from signal handler */
3649           break;
3650
3651         case DIB_Status_AppMod:
3652           TRACE("InSync requested in status AppMod\n" );
3653           /* no reason to do anything here, and this
3654            * shouldn't happen from signal handler */
3655           break;
3656       }
3657       break;
3658
3659     case DIB_Status_AppMod:
3660       /* App access - request access to write DIB surface */
3661       /* (typically called from signal handler) */
3662       switch (physBitmap->status)
3663       {
3664         default:
3665         case DIB_Status_None:
3666           /* shouldn't happen from signal handler */
3667           break;
3668
3669         case DIB_Status_GdiMod:
3670           TRACE("AppMod requested in status GdiMod\n" );
3671           X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
3672           X11DRV_DIB_DoUpdateDIBSection( physBitmap, TRUE );
3673           physBitmap->status = DIB_Status_AppMod;
3674           break;
3675
3676         case DIB_Status_InSync:
3677           TRACE("AppMod requested in status InSync\n" );
3678           X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
3679           physBitmap->status = DIB_Status_AppMod;
3680           break;
3681
3682         case DIB_Status_AppMod:
3683           TRACE("AppMod requested in status AppMod\n" );
3684           /* shouldn't happen from signal handler */
3685           break;
3686       }
3687       break;
3688
3689       /* it is up to the caller to do the copy/conversion, probably
3690        * using the return value to decide where to copy from */
3691     }
3692     LeaveCriticalSection(&physBitmap->lock);
3693     return ret;
3694 }
3695
3696 /***********************************************************************
3697  *           X11DRV_DIB_Lock
3698  */
3699 INT X11DRV_DIB_Lock(X_PHYSBITMAP *physBitmap, INT req)
3700 {
3701     INT ret = DIB_Status_None;
3702
3703     if (!physBitmap->image) return ret;  /* not a DIB section */
3704     TRACE("Locking %p from thread %04x\n", physBitmap->hbitmap, GetCurrentThreadId());
3705     EnterCriticalSection(&physBitmap->lock);
3706     ret = physBitmap->status;
3707     if (req != DIB_Status_None)
3708       X11DRV_DIB_Coerce(physBitmap, req);
3709     return ret;
3710 }
3711
3712 /***********************************************************************
3713  *           X11DRV_DIB_Unlock
3714  */
3715 void X11DRV_DIB_Unlock(X_PHYSBITMAP *physBitmap, BOOL commit)
3716 {
3717     if (!physBitmap->image) return;  /* not a DIB section */
3718     switch (physBitmap->status)
3719     {
3720       default:
3721       case DIB_Status_None:
3722         /* in case anyone is wondering, this is the "signal handler doesn't
3723          * work" case, where we always have to be ready for app access */
3724         if (commit) {
3725           switch (physBitmap->p_status)
3726           {
3727             case DIB_Status_GdiMod:
3728               TRACE("Unlocking and syncing from GdiMod\n" );
3729               X11DRV_DIB_DoUpdateDIBSection( physBitmap, TRUE );
3730               break;
3731
3732             default:
3733               TRACE("Unlocking without needing to sync\n" );
3734               break;
3735           }
3736         }
3737         else TRACE("Unlocking with no changes\n");
3738         physBitmap->p_status = DIB_Status_None;
3739         break;
3740
3741       case DIB_Status_GdiMod:
3742         TRACE("Unlocking in status GdiMod\n" );
3743         /* DIB was protected in Coerce */
3744         if (!commit) {
3745           /* no commit, revert to InSync if applicable */
3746           if ((physBitmap->p_status == DIB_Status_InSync) ||
3747               (physBitmap->p_status == DIB_Status_AppMod)) {
3748             X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READONLY );
3749             physBitmap->status = DIB_Status_InSync;
3750           }
3751         }
3752         break;
3753
3754       case DIB_Status_InSync:
3755         TRACE("Unlocking in status InSync\n" );
3756         /* DIB was already protected in Coerce */
3757         break;
3758
3759       case DIB_Status_AppMod:
3760         TRACE("Unlocking in status AppMod\n" );
3761         /* DIB was already protected in Coerce */
3762         /* this case is ordinary only called from the signal handler,
3763          * so we don't bother to check for !commit */
3764         break;
3765     }
3766     LeaveCriticalSection(&physBitmap->lock);
3767     TRACE("Unlocked %p\n", physBitmap->hbitmap);
3768 }
3769
3770 /***********************************************************************
3771  *           X11DRV_CoerceDIBSection
3772  */
3773 INT X11DRV_CoerceDIBSection(X11DRV_PDEVICE *physDev, INT req)
3774 {
3775     if (!physDev || !physDev->bitmap) return DIB_Status_None;
3776     return X11DRV_DIB_Coerce(physDev->bitmap, req);
3777 }
3778
3779 /***********************************************************************
3780  *           X11DRV_LockDIBSection
3781  */
3782 INT X11DRV_LockDIBSection(X11DRV_PDEVICE *physDev, INT req)
3783 {
3784     if (!physDev || !physDev->bitmap) return DIB_Status_None;
3785     return X11DRV_DIB_Lock(physDev->bitmap, req);
3786 }
3787
3788 /***********************************************************************
3789  *           X11DRV_UnlockDIBSection
3790  */
3791 void X11DRV_UnlockDIBSection(X11DRV_PDEVICE *physDev, BOOL commit)
3792 {
3793     if (!physDev || !physDev->bitmap) return;
3794     X11DRV_DIB_Unlock(physDev->bitmap, commit);
3795 }
3796
3797
3798 #ifdef HAVE_LIBXXSHM
3799 /***********************************************************************
3800  *           X11DRV_XShmErrorHandler
3801  *
3802  */
3803 static int XShmErrorHandler( Display *dpy, XErrorEvent *event, void *arg )
3804 {
3805     return 1;  /* FIXME: should check event contents */
3806 }
3807
3808 /***********************************************************************
3809  *           X11DRV_XShmCreateImage
3810  *
3811  */
3812 static XImage *X11DRV_XShmCreateImage( int width, int height, int bpp,
3813                                        XShmSegmentInfo* shminfo)
3814 {
3815     XImage *image;
3816
3817     image = XShmCreateImage(gdi_display, visual, bpp, ZPixmap, NULL, shminfo, width, height);
3818     if (image)
3819     {
3820         shminfo->shmid = shmget(IPC_PRIVATE, image->bytes_per_line * height,
3821                                   IPC_CREAT|0700);
3822         if( shminfo->shmid != -1 )
3823         {
3824             shminfo->shmaddr = shmat( shminfo->shmid, 0, 0 );
3825             if( shminfo->shmaddr != (char*)-1 )
3826             {
3827                 BOOL ok;
3828
3829                 shminfo->readOnly = FALSE;
3830                 X11DRV_expect_error( gdi_display, XShmErrorHandler, NULL );
3831                 ok = (XShmAttach( gdi_display, shminfo ) != 0);
3832                 XSync( gdi_display, False );
3833                 if (X11DRV_check_error()) ok = FALSE;
3834                 if (ok)
3835                 {
3836                     shmctl(shminfo->shmid, IPC_RMID, 0);
3837                     return image; /* Success! */
3838                 }
3839                 /* An error occurred */
3840                 shmdt(shminfo->shmaddr);
3841             }
3842             shmctl(shminfo->shmid, IPC_RMID, 0);
3843             shminfo->shmid = -1;
3844         }
3845         XFlush(gdi_display);
3846         XDestroyImage(image);
3847         image = NULL;
3848     }
3849     return image;
3850 }
3851 #endif /* HAVE_LIBXXSHM */
3852
3853 static Bool X11DRV_DIB_QueryXShm( Bool *pixmaps )
3854 {
3855     static Bool have_xshm, have_xshm_pixmaps;
3856     static BOOL initialized;
3857
3858     if (!initialized)
3859     {
3860 #ifdef HAVE_LIBXXSHM
3861         int major, minor;
3862
3863         have_xshm = XShmQueryVersion( gdi_display, &major, &minor, &have_xshm_pixmaps );
3864 #endif
3865         initialized = TRUE;
3866     }
3867
3868     *pixmaps = have_xshm_pixmaps;
3869     return have_xshm;
3870 }
3871
3872 /***********************************************************************
3873  *           X11DRV_CreateDIBSection   (X11DRV.@)
3874  */
3875 HBITMAP X11DRV_CreateDIBSection( PHYSDEV dev, HBITMAP hbitmap, BITMAPINFO *bmi, UINT usage )
3876 {
3877     X11DRV_PDEVICE *physDev = get_x11drv_dev( dev );
3878     X_PHYSBITMAP *physBitmap;
3879     DIBSECTION dib;
3880 #ifdef HAVE_LIBXXSHM
3881     Bool pixmaps;
3882 #endif
3883
3884     if (!(physBitmap = X11DRV_init_phys_bitmap( hbitmap ))) return 0;
3885     physBitmap->topdown = bmi->bmiHeader.biHeight < 0;
3886     physBitmap->status = DIB_Status_None;
3887
3888     GetObjectW( hbitmap, sizeof(dib), &dib );
3889
3890     /* create color map */
3891     if (dib.dsBm.bmBitsPixel <= 8)
3892     {
3893         physBitmap->colorMap = X11DRV_DIB_BuildColorMap( physDev,
3894                                                          usage, dib.dsBm.bmBitsPixel, bmi,
3895                                                          &physBitmap->nColorMap );
3896     }
3897
3898     if (!X11DRV_XRender_SetPhysBitmapDepth( physBitmap, dib.dsBm.bmBitsPixel, &dib ))
3899     {
3900         if (dib.dsBm.bmBitsPixel == 1)
3901         {
3902             physBitmap->depth = 1;
3903             physBitmap->trueColor = FALSE;
3904         }
3905         else
3906         {
3907             physBitmap->depth = screen_depth;
3908             physBitmap->color_shifts = X11DRV_PALETTE_default_shifts;
3909             physBitmap->trueColor = (visual->class == TrueColor || visual->class == DirectColor);
3910         }
3911     }
3912
3913     /* create pixmap and X image */
3914     wine_tsx11_lock();
3915 #ifdef HAVE_LIBXXSHM
3916     physBitmap->shminfo.shmid = -1;
3917
3918     if (X11DRV_DIB_QueryXShm( &pixmaps )
3919             && (physBitmap->image = X11DRV_XShmCreateImage( dib.dsBm.bmWidth, dib.dsBm.bmHeight,
3920                                                             physBitmap->depth, &physBitmap->shminfo )))
3921     {
3922         if (pixmaps)
3923         {
3924             physBitmap->shm_mode = X11DRV_SHM_PIXMAP;
3925             physBitmap->image->data = HeapAlloc( GetProcessHeap(), 0,
3926                     dib.dsBm.bmHeight * physBitmap->image->bytes_per_line );
3927         }
3928         else
3929         {
3930             physBitmap->shm_mode = X11DRV_SHM_IMAGE;
3931             physBitmap->image->data = physBitmap->shminfo.shmaddr;
3932         }
3933     }
3934     else
3935 #endif
3936     {
3937         physBitmap->shm_mode = X11DRV_SHM_NONE;
3938         physBitmap->image = X11DRV_DIB_CreateXImage( dib.dsBm.bmWidth, dib.dsBm.bmHeight,
3939                                                      physBitmap->depth );
3940     }
3941
3942 #ifdef HAVE_LIBXXSHM
3943     if (physBitmap->shm_mode == X11DRV_SHM_PIXMAP)
3944     {
3945         TRACE("Creating shared pixmap for bmp %p.\n", physBitmap->hbitmap);
3946         physBitmap->pixmap = XShmCreatePixmap( gdi_display, root_window,
3947                                                physBitmap->shminfo.shmaddr, &physBitmap->shminfo,
3948                                                dib.dsBm.bmWidth, dib.dsBm.bmHeight,
3949                                                physBitmap->depth );
3950     }
3951     else
3952 #endif
3953     {
3954         physBitmap->pixmap = XCreatePixmap( gdi_display, root_window, dib.dsBm.bmWidth,
3955                                             dib.dsBm.bmHeight, physBitmap->depth );
3956     }
3957
3958     wine_tsx11_unlock();
3959     if (!physBitmap->pixmap || !physBitmap->image) return 0;
3960
3961     if (physBitmap->trueColor)
3962     {
3963         ColorShifts *shifts = &physBitmap->color_shifts;
3964
3965         /* When XRender is around and used, we also support dibsections in other formats like 16-bit. In these
3966          * cases we need to override the mask of XImages. The reason is that during XImage creation the masks are
3967          * derived from a 24-bit visual (no 16-bit ones are around when X runs at 24-bit). SetImageBits and other
3968          * functions rely on the color masks for proper color conversion, so we need to override the masks here. */
3969         physBitmap->image->red_mask = shifts->physicalRed.max << shifts->physicalRed.shift;
3970         physBitmap->image->green_mask = shifts->physicalGreen.max << shifts->physicalGreen.shift;
3971         physBitmap->image->blue_mask = shifts->physicalBlue.max << shifts->physicalBlue.shift;
3972     }
3973
3974       /* install fault handler */
3975     InitializeCriticalSection( &physBitmap->lock );
3976     physBitmap->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": X_PHYSBITMAP.lock");
3977
3978     physBitmap->base   = dib.dsBm.bmBits;
3979     physBitmap->size   = dib.dsBmih.biSizeImage;
3980     physBitmap->status = DIB_Status_AppMod;
3981
3982     if (!dibs_handler)
3983         dibs_handler = AddVectoredExceptionHandler( TRUE, X11DRV_DIB_FaultHandler );
3984     EnterCriticalSection( &dibs_cs );
3985     list_add_head( &dibs_list, &physBitmap->entry );
3986     LeaveCriticalSection( &dibs_cs );
3987
3988     X11DRV_DIB_DoProtectDIBSection( physBitmap, PAGE_READWRITE );
3989
3990     return hbitmap;
3991 }
3992
3993 /***********************************************************************
3994  *           X11DRV_DIB_DeleteDIBSection
3995  */
3996 void X11DRV_DIB_DeleteDIBSection(X_PHYSBITMAP *physBitmap, DIBSECTION *dib)
3997 {
3998   BOOL last;
3999
4000   EnterCriticalSection( &dibs_cs );
4001   list_remove( &physBitmap->entry );
4002   last = list_empty( &dibs_list );
4003   LeaveCriticalSection( &dibs_cs );
4004
4005   if (last)
4006   {
4007       RemoveVectoredExceptionHandler( dibs_handler );
4008       dibs_handler = NULL;
4009   }
4010
4011   if (dib->dshSection)
4012       X11DRV_DIB_Coerce(physBitmap, DIB_Status_InSync);
4013
4014   if (physBitmap->image)
4015   {
4016       wine_tsx11_lock();
4017 #ifdef HAVE_LIBXXSHM
4018       if (physBitmap->shminfo.shmid != -1)
4019       {
4020           XShmDetach( gdi_display, &(physBitmap->shminfo) );
4021           if (physBitmap->shm_mode == X11DRV_SHM_PIXMAP) X11DRV_DIB_DestroyXImage( physBitmap->image );
4022           else XDestroyImage( physBitmap->image );
4023           shmdt( physBitmap->shminfo.shmaddr );
4024           physBitmap->shminfo.shmid = -1;
4025           physBitmap->shm_mode = X11DRV_SHM_NONE;
4026       }
4027       else
4028 #endif
4029           X11DRV_DIB_DestroyXImage( physBitmap->image );
4030       wine_tsx11_unlock();
4031   }
4032
4033   HeapFree(GetProcessHeap(), 0, physBitmap->colorMap);
4034   physBitmap->lock.DebugInfo->Spare[0] = 0;
4035   DeleteCriticalSection(&physBitmap->lock);
4036 }
4037
4038 /***********************************************************************
4039  *           SetDIBColorTable   (X11DRV.@)
4040  */
4041 UINT X11DRV_SetDIBColorTable( PHYSDEV dev, UINT start, UINT count, const RGBQUAD *colors )
4042 {
4043     X11DRV_PDEVICE *physDev = get_x11drv_dev( dev );
4044     DIBSECTION dib;
4045     UINT ret = 0;
4046     X_PHYSBITMAP *physBitmap = physDev->bitmap;
4047
4048     if (!physBitmap) return 0;
4049     GetObjectW( physBitmap->hbitmap, sizeof(dib), &dib );
4050
4051     if (physBitmap->colorMap && start < physBitmap->nColorMap) {
4052         UINT end = count + start;
4053         if (end > physBitmap->nColorMap) end = physBitmap->nColorMap;
4054         /*
4055          * Changing color table might change the mapping between
4056          * DIB colors and X11 colors and thus alter the visible state
4057          * of the bitmap object.
4058          */
4059         /*
4060          * FIXME we need to recalculate the pen, brush, text and bkgnd pixels here,
4061          * at least for a 1 bpp dibsection
4062          */
4063         X11DRV_DIB_Lock( physBitmap, DIB_Status_AppMod );
4064         X11DRV_DIB_GenColorMap( physDev, physBitmap->colorMap, DIB_RGB_COLORS,
4065                                 dib.dsBm.bmBitsPixel, colors, start, end );
4066         X11DRV_DIB_Unlock( physBitmap, TRUE );
4067         ret = end - start;
4068     }
4069     return ret;
4070 }
4071
4072
4073 /***********************************************************************
4074  *           X11DRV_DIB_CreateDIBFromBitmap
4075  *
4076  *  Allocates a packed DIB and copies the bitmap data into it.
4077  */
4078 HGLOBAL X11DRV_DIB_CreateDIBFromBitmap(HDC hdc, HBITMAP hBmp)
4079 {
4080     BITMAP bmp;
4081     HGLOBAL hPackedDIB;
4082     LPBYTE pPackedDIB;
4083     LPBITMAPINFOHEADER pbmiHeader;
4084     unsigned int cDataSize, cPackedSize, OffsetBits;
4085     int nLinesCopied;
4086
4087     if (!GetObjectW( hBmp, sizeof(bmp), &bmp )) return 0;
4088
4089     /*
4090      * A packed DIB contains a BITMAPINFO structure followed immediately by
4091      * an optional color palette and the pixel data.
4092      */
4093
4094     /* Calculate the size of the packed DIB */
4095     cDataSize = X11DRV_DIB_GetDIBWidthBytes( bmp.bmWidth, bmp.bmBitsPixel ) * abs( bmp.bmHeight );
4096     cPackedSize = sizeof(BITMAPINFOHEADER)
4097                   + ( (bmp.bmBitsPixel <= 8) ? (sizeof(RGBQUAD) * (1 << bmp.bmBitsPixel)) : 0 )
4098                   + cDataSize;
4099     /* Get the offset to the bits */
4100     OffsetBits = cPackedSize - cDataSize;
4101
4102     /* Allocate the packed DIB */
4103     TRACE("\tAllocating packed DIB of size %d\n", cPackedSize);
4104     hPackedDIB = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE /*| GMEM_ZEROINIT*/,
4105                              cPackedSize );
4106     if ( !hPackedDIB )
4107     {
4108         WARN("Could not allocate packed DIB!\n");
4109         return 0;
4110     }
4111
4112     /* A packed DIB starts with a BITMAPINFOHEADER */
4113     pPackedDIB = GlobalLock(hPackedDIB);
4114     pbmiHeader = (LPBITMAPINFOHEADER)pPackedDIB;
4115
4116     /* Init the BITMAPINFOHEADER */
4117     pbmiHeader->biSize = sizeof(BITMAPINFOHEADER);
4118     pbmiHeader->biWidth = bmp.bmWidth;
4119     pbmiHeader->biHeight = bmp.bmHeight;
4120     pbmiHeader->biPlanes = 1;
4121     pbmiHeader->biBitCount = bmp.bmBitsPixel;
4122     pbmiHeader->biCompression = BI_RGB;
4123     pbmiHeader->biSizeImage = 0;
4124     pbmiHeader->biXPelsPerMeter = pbmiHeader->biYPelsPerMeter = 0;
4125     pbmiHeader->biClrUsed = 0;
4126     pbmiHeader->biClrImportant = 0;
4127
4128     /* Retrieve the DIB bits from the bitmap and fill in the
4129      * DIB color table if present */
4130
4131     nLinesCopied = GetDIBits(hdc,                       /* Handle to device context */
4132                              hBmp,                      /* Handle to bitmap */
4133                              0,                         /* First scan line to set in dest bitmap */
4134                              bmp.bmHeight,              /* Number of scan lines to copy */
4135                              pPackedDIB + OffsetBits,   /* [out] Address of array for bitmap bits */
4136                              (LPBITMAPINFO) pbmiHeader, /* [out] Address of BITMAPINFO structure */
4137                              0);                        /* RGB or palette index */
4138     GlobalUnlock(hPackedDIB);
4139
4140     /* Cleanup if GetDIBits failed */
4141     if (nLinesCopied != bmp.bmHeight)
4142     {
4143         TRACE("\tGetDIBits returned %d. Actual lines=%d\n", nLinesCopied, bmp.bmHeight);
4144         GlobalFree(hPackedDIB);
4145         hPackedDIB = 0;
4146     }
4147     return hPackedDIB;
4148 }
4149
4150
4151 /**************************************************************************
4152  *              X11DRV_DIB_CreateDIBFromPixmap
4153  *
4154  *  Allocates a packed DIB and copies the Pixmap data into it.
4155  *  The Pixmap passed in is deleted after the conversion.
4156  */
4157 HGLOBAL X11DRV_DIB_CreateDIBFromPixmap(Pixmap pixmap, HDC hdc)
4158 {
4159     HDC hdcMem;
4160     X_PHYSBITMAP *physBitmap;
4161     Pixmap orig_pixmap;
4162     HBITMAP hBmp = 0;
4163     HGLOBAL hPackedDIB = 0;
4164     Window root;
4165     int x,y;               /* Unused */
4166     unsigned border_width; /* Unused */
4167     unsigned int depth, width, height;
4168
4169     /* Get the Pixmap dimensions and bit depth */
4170     wine_tsx11_lock();
4171     if (!XGetGeometry(gdi_display, pixmap, &root, &x, &y, &width, &height,
4172                       &border_width, &depth)) depth = 0;
4173     wine_tsx11_unlock();
4174     if (!pixmap_formats[depth]) return 0;
4175
4176     TRACE("\tPixmap properties: width=%d, height=%d, depth=%d\n",
4177           width, height, depth);
4178
4179     /*
4180      * Create an HBITMAP with the same dimensions and BPP as the pixmap,
4181      * and make it a container for the pixmap passed.
4182      */
4183     if (!(hBmp = CreateBitmap( width, height, 1, pixmap_formats[depth]->bits_per_pixel, NULL ))) return 0;
4184
4185     /* force bitmap to be owned by a screen DC */
4186     hdcMem = CreateCompatibleDC( hdc );
4187     SelectObject( hdcMem, SelectObject( hdcMem, hBmp ));
4188     DeleteDC( hdcMem );
4189
4190     physBitmap = X11DRV_get_phys_bitmap( hBmp );
4191
4192     /* swap the new pixmap in */
4193     orig_pixmap = physBitmap->pixmap;
4194     physBitmap->pixmap = pixmap;
4195
4196     /*
4197      * Create a packed DIB from the Pixmap wrapper bitmap created above.
4198      * A packed DIB contains a BITMAPINFO structure followed immediately by
4199      * an optional color palette and the pixel data.
4200      */
4201     hPackedDIB = X11DRV_DIB_CreateDIBFromBitmap(hdc, hBmp);
4202
4203     /* we can now get rid of the HBITMAP and its original pixmap */
4204     physBitmap->pixmap = orig_pixmap;
4205     DeleteObject(hBmp);
4206
4207     TRACE("\tReturning packed DIB %p\n", hPackedDIB);
4208     return hPackedDIB;
4209 }
4210
4211
4212 /**************************************************************************
4213  *                 X11DRV_DIB_CreatePixmapFromDIB
4214  *
4215  *    Creates a Pixmap from a packed DIB
4216  */
4217 Pixmap X11DRV_DIB_CreatePixmapFromDIB( HGLOBAL hPackedDIB, HDC hdc )
4218 {
4219     Pixmap pixmap = 0;
4220     X_PHYSBITMAP *physBitmap;
4221     HBITMAP hBmp;
4222     LPBITMAPINFO pbmi;
4223     HDC memdc;
4224
4225     /* Create a DDB from the DIB */
4226
4227     pbmi = GlobalLock(hPackedDIB);
4228     hBmp = CreateDIBitmap(hdc, &pbmi->bmiHeader, CBM_INIT,
4229                           (LPBYTE)pbmi + bitmap_info_size( pbmi, DIB_RGB_COLORS ),
4230                           pbmi, DIB_RGB_COLORS);
4231     GlobalUnlock(hPackedDIB);
4232
4233     /* make sure it's owned by x11drv */
4234     memdc = CreateCompatibleDC( hdc );
4235     SelectObject( memdc, hBmp );
4236     DeleteDC( memdc );
4237
4238     /* clear the physBitmap so that we can steal its pixmap */
4239     if ((physBitmap = X11DRV_get_phys_bitmap( hBmp )))
4240     {
4241         pixmap = physBitmap->pixmap;
4242         physBitmap->pixmap = 0;
4243     }
4244
4245     /* Delete the DDB we created earlier now that we have stolen its pixmap */
4246     DeleteObject(hBmp);
4247
4248     TRACE("Returning Pixmap %lx\n", pixmap);
4249     return pixmap;
4250 }