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

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