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