git.oblomov.eu Git - wine/blob - graphics/x11drv/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include "config.h"
  22
  23 #include "ts_xlib.h"
  24 #ifdef HAVE_LIBXXSHM
  25 #include <X11/extensions/XShm.h>
  26 # ifdef HAVE_SYS_SHM_H
  27 #  include <sys/shm.h>
  28 # endif
  29 # ifdef HAVE_SYS_IPC_H
  30 #  include <sys/ipc.h>
  31 # endif
  32 #endif /* defined(HAVE_LIBXXSHM) */
  33
  34 #include <stdlib.h>
  35 #include <string.h>
  36 #include "windef.h"
  37 #include "bitmap.h"
  38 #include "x11drv.h"
  39 #include "wine/debug.h"
  40 #include "gdi.h"
  41 #include "palette.h"
  42 #include "global.h"
  43
  44 WINE_DEFAULT_DEBUG_CHANNEL(bitmap);
  45 WINE_DECLARE_DEBUG_CHANNEL(x11drv);
  46
  47 static int ximageDepthTable[32];
  48
  49 /* This structure holds the arguments for DIB_SetImageBits() */
  50 typedef struct
  51 {
  52     X11DRV_PDEVICE *physDev;
  53     LPCVOID         bits;
  54     XImage         *image;
  55     PALETTEENTRY   *palentry;
  56     int             lines;
  57     DWORD           infoWidth;
  58     WORD            depth;
  59     WORD            infoBpp;
  60     WORD            compression;
  61     RGBQUAD        *colorMap;
  62     int             nColorMap;
  63     Drawable        drawable;
  64     GC              gc;
  65     int             xSrc;
  66     int             ySrc;
  67     int             xDest;
  68     int             yDest;
  69     int             width;
  70     int             height;
  71     DWORD           rMask;
  72     DWORD           gMask;
  73     DWORD           bMask;
  74     BOOL            useShm;
  75     int             dibpitch;
  76 } X11DRV_DIB_IMAGEBITS_DESCR;
  77
  78
  79 enum Rle_EscapeCodes
  80 {
  81   RLE_EOL   = 0, /* End of line */
  82   RLE_END   = 1, /* End of bitmap */
  83   RLE_DELTA = 2  /* Delta */
  84 };
  85
  86 /***********************************************************************
  87  *           X11DRV_DIB_GetXImageWidthBytes
  88  *
  89  * Return the width of an X image in bytes
  90  */
  91 inline static int X11DRV_DIB_GetXImageWidthBytes( int width, int depth )
  92 {
  93     if (!depth || depth > 32) goto error;
  94
  95     if (!ximageDepthTable[depth-1])
  96     {
  97         XImage *testimage = XCreateImage( gdi_display, visual, depth,
  98                                           ZPixmap, 0, NULL, 1, 1, 32, 20 );
  99         if (testimage)
 100         {
 101             ximageDepthTable[depth-1] = testimage->bits_per_pixel;
 102             XDestroyImage( testimage );
 103         }
 104         else ximageDepthTable[depth-1] = -1;
 105     }
 106     if (ximageDepthTable[depth-1] != -1)
 107         return (4 * ((width * ximageDepthTable[depth-1] + 31) / 32));
 108
 109  error:
 110     WARN( "(%d): Unsupported depth\n", depth );
 111     return 4 * width;
 112 }
 113
 114
 115 /***********************************************************************
 116  *           X11DRV_DIB_CreateXImage
 117  *
 118  * Create an X image.
 119  */
 120 XImage *X11DRV_DIB_CreateXImage( int width, int height, int depth )
 121 {
 122     int width_bytes;
 123     XImage *image;
 124
 125     wine_tsx11_lock();
 126     width_bytes = X11DRV_DIB_GetXImageWidthBytes( width, depth );
 127     image = XCreateImage( gdi_display, visual, depth, ZPixmap, 0,
 128                           calloc( height, width_bytes ),
 129                           width, height, 32, width_bytes );
 130     wine_tsx11_unlock();
 131     return image;
 132 }
 133
 134
 135 /***********************************************************************
 136  *           DIB_GetBitmapInfo
 137  *
 138  * Get the info from a bitmap header.
 139  * Return 1 for INFOHEADER, 0 for COREHEADER, -1 for error.
 140  */
 141 static int DIB_GetBitmapInfo( const BITMAPINFOHEADER *header, DWORD *width,
 142                               int *height, WORD *bpp, WORD *compr )
 143 {
 144     if (header->biSize == sizeof(BITMAPCOREHEADER))
 145     {
 146         BITMAPCOREHEADER *core = (BITMAPCOREHEADER *)header;
 147         *width  = core->bcWidth;
 148         *height = core->bcHeight;
 149         *bpp    = core->bcBitCount;
 150         *compr  = 0;
 151         return 0;
 152     }
 153     if (header->biSize >= sizeof(BITMAPINFOHEADER))
 154     {
 155         *width  = header->biWidth;
 156         *height = header->biHeight;
 157         *bpp    = header->biBitCount;
 158         *compr  = header->biCompression;
 159         return 1;
 160     }
 161     ERR("(%ld): unknown/wrong size for header\n", header->biSize );
 162     return -1;
 163 }
 164
 165
 166 /***********************************************************************
 167  *           X11DRV_DIB_GenColorMap
 168  *
 169  * Fills the color map of a bitmap palette. Should not be called
 170  * for a >8-bit deep bitmap.
 171  */
 172 int *X11DRV_DIB_GenColorMap( X11DRV_PDEVICE *physDev, int *colorMapping,
 173                              WORD coloruse, WORD depth, BOOL quads,
 174                              const void *colorPtr, int start, int end )
 175 {
 176     int i;
 177
 178     if (coloruse == DIB_RGB_COLORS)
 179     {
 180         int max = 1 << depth;
 181
 182         if (end > max) end = max;
 183
 184         if (quads)
 185         {
 186             RGBQUAD * rgb = (RGBQUAD *)colorPtr;
 187
 188             if (depth == 1)  /* Monochrome */
 189                 for (i = start; i < end; i++, rgb++)
 190                     colorMapping[i] = (rgb->rgbRed + rgb->rgbGreen +
 191                                        rgb->rgbBlue > 255*3/2);
 192             else
 193                 for (i = start; i < end; i++, rgb++)
 194                     colorMapping[i] = X11DRV_PALETTE_ToPhysical( physDev, RGB(rgb->rgbRed,
 195                                                                 rgb->rgbGreen,
 196                                                                 rgb->rgbBlue));
 197         }
 198         else
 199         {
 200             RGBTRIPLE * rgb = (RGBTRIPLE *)colorPtr;
 201
 202             if (depth == 1)  /* Monochrome */
 203                 for (i = start; i < end; i++, rgb++)
 204                     colorMapping[i] = (rgb->rgbtRed + rgb->rgbtGreen +
 205                                        rgb->rgbtBlue > 255*3/2);
 206             else
 207                 for (i = start; i < end; i++, rgb++)
 208                     colorMapping[i] = X11DRV_PALETTE_ToPhysical( physDev, RGB(rgb->rgbtRed,
 209                                                                rgb->rgbtGreen,
 210                                                                rgb->rgbtBlue));
 211         }
 212     }
 213     else  /* DIB_PAL_COLORS */
 214     {
 215         if (colorPtr) {
 216             WORD * index = (WORD *)colorPtr;
 217
 218             for (i = start; i < end; i++, index++)
 219                 colorMapping[i] = X11DRV_PALETTE_ToPhysical( physDev, PALETTEINDEX(*index) );
 220         } else {
 221             for (i = start; i < end; i++)
 222                 colorMapping[i] = X11DRV_PALETTE_ToPhysical( physDev, PALETTEINDEX(i) );
 223         }
 224     }
 225
 226     return colorMapping;
 227 }
 228
 229 /***********************************************************************
 230  *           X11DRV_DIB_BuildColorMap
 231  *
 232  * Build the color map from the bitmap palette. Should not be called
 233  * for a >8-bit deep bitmap.
 234  */
 235 int *X11DRV_DIB_BuildColorMap( X11DRV_PDEVICE *physDev, WORD coloruse, WORD depth,
 236                                const BITMAPINFO *info, int *nColors )
 237 {
 238     int colors;
 239     BOOL isInfo;
 240     const void *colorPtr;
 241     int *colorMapping;
 242
 243     if ((isInfo = (info->bmiHeader.biSize == sizeof(BITMAPINFOHEADER))))
 244     {
 245         colors = info->bmiHeader.biClrUsed;
 246         if (!colors) colors = 1 << info->bmiHeader.biBitCount;
 247         colorPtr = info->bmiColors;
 248     }
 249     else  /* assume BITMAPCOREINFO */
 250     {
 251         colors = 1 << ((BITMAPCOREHEADER *)&info->bmiHeader)->bcBitCount;
 252         colorPtr = (WORD *)((BITMAPCOREINFO *)info)->bmciColors;
 253     }
 254
 255     if (colors > 256)
 256     {
 257         ERR("called with >256 colors!\n");
 258         return NULL;
 259     }
 260
 261     /* just so CopyDIBSection doesn't have to create an identity palette */
 262     if (coloruse == (WORD)-1) colorPtr = NULL;
 263
 264     if (!(colorMapping = (int *)HeapAlloc(GetProcessHeap(), 0,
 265                                           colors * sizeof(int) )))
 266         return NULL;
 267
 268     *nColors = colors;
 269     return X11DRV_DIB_GenColorMap( physDev, colorMapping, coloruse, depth,
 270                                    isInfo, colorPtr, 0, colors);
 271 }
 272
 273
 274 /***********************************************************************
 275  *           X11DRV_DIB_MapColor
 276  */
 277 int X11DRV_DIB_MapColor( int *physMap, int nPhysMap, int phys, int oldcol )
 278 {
 279     int color;
 280
 281     if ((oldcol < nPhysMap) && (physMap[oldcol] == phys))
 282         return oldcol;
 283
 284     for (color = 0; color < nPhysMap; color++)
 285         if (physMap[color] == phys)
 286             return color;
 287
 288     WARN("Strange color %08x\n", phys);
 289     return 0;
 290 }
 291
 292
 293 /*********************************************************************
 294  *         X11DRV_DIB_GetNearestIndex
 295  *
 296  * Helper for X11DRV_DIB_GetDIBits.
 297  * Returns the nearest colour table index for a given RGB.
 298  * Nearest is defined by minimizing the sum of the squares.
 299  */
 300 static INT X11DRV_DIB_GetNearestIndex(RGBQUAD *colormap, int numColors, BYTE r, BYTE g, BYTE b)
 301 {
 302     INT i, best = -1, diff, bestdiff = -1;
 303     RGBQUAD *color;
 304
 305     for(color = colormap, i = 0; i < numColors; color++, i++) {
 306         diff = (r - color->rgbRed) * (r - color->rgbRed) +
 307                (g - color->rgbGreen) * (g - color->rgbGreen) +
 308                (b - color->rgbBlue) * (b - color->rgbBlue);
 309         if(diff == 0)
 310             return i;
 311         if(best == -1 || diff < bestdiff) {
 312             best = i;
 313             bestdiff = diff;
 314         }
 315     }
 316     return best;
 317 }
 318 /*********************************************************************
 319  *         X11DRV_DIB_MaskToShift
 320  *
 321  * Helper for X11DRV_DIB_GetDIBits.
 322  * Returns the by how many bits to shift a given color so that it is
 323  * in the proper position.
 324  */
 325 static INT X11DRV_DIB_MaskToShift(DWORD mask)
 326 {
 327     int shift;
 328
 329     if (mask==0)
 330         return 0;
 331
 332     shift=0;
 333     while ((mask&1)==0) {
 334         mask>>=1;
 335         shift++;
 336     }
 337     return shift;
 338 }
 339
 340 /***********************************************************************
 341  *           X11DRV_DIB_Convert_any_asis
 342  *
 343  * All X11DRV_DIB_Convert_Xxx functions take at least the following
 344  * parameters:
 345  * - width
 346  *   This is the width in pixel of the surface to copy. This may be less
 347  *   than the full width of the image.
 348  * - height
 349  *   The number of lines to copy. This may be less than the full height
 350  *   of the image. This is always >0.
 351  * - srcbits
 352  *   Points to the first byte containing data to be copied. If the source
 353  *   surface starts are coordinates (x,y) then this is:
 354  *   image_ptr+x*bytes_pre_pixel+y*bytes_per_line
 355  *   (with further adjustments for top-down/bottom-up images)
 356  * - srclinebytes
 357  *   This is the number of bytes per line. It may be >0 or <0 depending on
 358  *   whether this is a top-down or bottom-up image.
 359  * - dstbits
 360  *   Same as srcbits but for the destination
 361  * - dstlinebytes
 362  *   Same as srclinebytes but for the destination.
 363  *
 364  * Notes:
 365  * - The supported Dib formats are: pal1, pal4, pal8, rgb555, bgr555,
 366  *   rgb565, bgr565, rgb888 and any 32bit (0888) format.
 367  *   The supported XImage (Bmp) formats are: pal1, pal4, pal8,
 368  *   rgb555, bgr555, rgb565, bgr565, rgb888, bgr888, rgb0888, bgr0888.
 369  * - Rgb formats are those for which the masks are such that:
 370  *   red_mask > green_mask > blue_mask
 371  * - Bgr formats are those for which the masks sort in the other direction.
 372  * - Many conversion functions handle both rgb->bgr and bgr->rgb conversions
 373  *   so the comments use h, g, l to mean respectively the source color in the
 374  *   high bits, the green, and the source color in the low bits.
 375  */
 376 static void X11DRV_DIB_Convert_any_asis(int width, int height,
 377                                     int bytes_per_pixel,
 378                                     const void* srcbits, int srclinebytes,
 379                                     void* dstbits, int dstlinebytes)
 380 {
 381     int y;
 382
 383     width*=bytes_per_pixel;
 384     for (y=0; y<height; y++) {
 385         memcpy(dstbits, srcbits, width);
 386         srcbits = (char*)srcbits + srclinebytes;
 387         dstbits = (char*)dstbits + dstlinebytes;
 388     }
 389 }
 390
 391 /*
 392  * 15 bit conversions
 393  */
 394
 395 static void X11DRV_DIB_Convert_555_reverse(int width, int height,
 396                                     const void* srcbits, int srclinebytes,
 397                                     void* dstbits, int dstlinebytes)
 398 {
 399     const DWORD* srcpixel;
 400     DWORD* dstpixel;
 401     int x,y;
 402
 403     for (y=0; y<height; y++) {
 404         srcpixel=srcbits;
 405         dstpixel=dstbits;
 406         for (x=0; x<width/2; x++) {
 407             /* Do 2 pixels at a time */
 408             DWORD srcval;
 409             srcval=*srcpixel++;
 410             *dstpixel++=((srcval << 10) & 0x7c007c00) | /* h */
 411                         ( srcval        & 0x03e003e0) | /* g */
 412                         ((srcval >> 10) & 0x001f001f);  /* l */
 413         }
 414         if (width&1) {
 415             /* And the the odd pixel */
 416             WORD srcval;
 417             srcval=*((WORD*)srcpixel);
 418             *((WORD*)dstpixel)=((srcval << 10) & 0x7c00) | /* h */
 419                                ( srcval        & 0x03e0) | /* g */
 420                                ((srcval >> 10) & 0x001f);  /* l */
 421         }
 422         srcbits = (char*)srcbits + srclinebytes;
 423         dstbits = (char*)dstbits + dstlinebytes;
 424     }
 425 }
 426
 427 static void X11DRV_DIB_Convert_555_to_565_asis(int width, int height,
 428                                     const void* srcbits, int srclinebytes,
 429                                     void* dstbits, int dstlinebytes)
 430 {
 431     const DWORD* srcpixel;
 432     DWORD* dstpixel;
 433     int x,y;
 434
 435     for (y=0; y<height; y++) {
 436         srcpixel=srcbits;
 437         dstpixel=dstbits;
 438         for (x=0; x<width/2; x++) {
 439             /* Do 2 pixels at a time */
 440             DWORD srcval;
 441             srcval=*srcpixel++;
 442             *dstpixel++=((srcval << 1) & 0xffc0ffc0) | /* h, g */
 443                         ((srcval >> 4) & 0x00200020) | /* g - 1 bit */
 444                         ( srcval       & 0x001f001f);  /* l */
 445         }
 446         if (width&1) {
 447             /* And the the odd pixel */
 448             WORD srcval;
 449             srcval=*((WORD*)srcpixel);
 450             *((WORD*)dstpixel)=((srcval << 1) & 0xffc0) | /* h, g */
 451                                ((srcval >> 4) & 0x0020) | /* g - 1 bit */
 452                                 (srcval       & 0x001f);  /* l */
 453         }
 454         srcbits = (char*)srcbits + srclinebytes;
 455         dstbits = (char*)dstbits + dstlinebytes;
 456     }
 457 }
 458
 459 static void X11DRV_DIB_Convert_555_to_565_reverse(int width, int height,
 460                                     const void* srcbits, int srclinebytes,
 461                                     void* dstbits, int dstlinebytes)
 462 {
 463     const DWORD* srcpixel;
 464     DWORD* dstpixel;
 465     int x,y;
 466
 467     for (y=0; y<height; y++) {
 468         srcpixel=srcbits;
 469         dstpixel=dstbits;
 470         for (x=0; x<width/2; x++) {
 471             /* Do 2 pixels at a time */
 472             DWORD srcval;
 473             srcval=*srcpixel++;
 474             *dstpixel++=((srcval >> 10) & 0x001f001f) | /* h */
 475                         ((srcval <<  1) & 0x07c007c0) | /* g */
 476                         ((srcval >>  4) & 0x00200020) | /* g - 1 bit */
 477                         ((srcval << 11) & 0xf800f800);  /* l */
 478         }
 479         if (width&1) {
 480             /* And the the odd pixel */
 481             WORD srcval;
 482             srcval=*((WORD*)srcpixel);
 483             *((WORD*)dstpixel)=((srcval >> 10) & 0x001f) | /* h */
 484                                ((srcval <<  1) & 0x07c0) | /* g */
 485                                ((srcval >>  4) & 0x0020) | /* g - 1 bit */
 486                                ((srcval << 11) & 0xf800);  /* l */
 487         }
 488         srcbits = (char*)srcbits + srclinebytes;
 489         dstbits = (char*)dstbits + dstlinebytes;
 490     }
 491 }
 492
 493 static void X11DRV_DIB_Convert_555_to_888_asis(int width, int height,
 494                                     const void* srcbits, int srclinebytes,
 495                                     void* dstbits, int dstlinebytes)
 496 {
 497     const WORD* srcpixel;
 498     BYTE* dstpixel;
 499     int x,y;
 500
 501     for (y=0; y<height; y++) {
 502         srcpixel=srcbits;
 503         dstpixel=dstbits;
 504         for (x=0; x<width; x++) {
 505             WORD srcval;
 506             srcval=*srcpixel++;
 507             dstpixel[0]=((srcval <<  3) & 0xf8) | /* l */
 508                         ((srcval >>  2) & 0x07);  /* l - 3 bits */
 509             dstpixel[1]=((srcval >>  2) & 0xf8) | /* g */
 510                         ((srcval >>  7) & 0x07);  /* g - 3 bits */
 511             dstpixel[2]=((srcval >>  7) & 0xf8) | /* h */
 512                         ((srcval >> 12) & 0x07);  /* h - 3 bits */
 513             dstpixel+=3;
 514         }
 515         srcbits = (char*)srcbits + srclinebytes;
 516         dstbits = (char*)dstbits + dstlinebytes;
 517     }
 518 }
 519
 520 static void X11DRV_DIB_Convert_555_to_888_reverse(int width, int height,
 521                                     const void* srcbits, int srclinebytes,
 522                                     void* dstbits, int dstlinebytes)
 523 {
 524     const WORD* srcpixel;
 525     BYTE* dstpixel;
 526     int x,y;
 527
 528     for (y=0; y<height; y++) {
 529         srcpixel=srcbits;
 530         dstpixel=dstbits;
 531         for (x=0; x<width; x++) {
 532             WORD srcval;
 533             srcval=*srcpixel++;
 534             dstpixel[0]=((srcval >>  7) & 0xf8) | /* h */
 535                         ((srcval >> 12) & 0x07);  /* h - 3 bits */
 536             dstpixel[1]=((srcval >>  2) & 0xf8) | /* g */
 537                         ((srcval >>  7) & 0x07);  /* g - 3 bits */
 538             dstpixel[2]=((srcval <<  3) & 0xf8) | /* l */
 539                         ((srcval >>  2) & 0x07);  /* l - 3 bits */
 540             dstpixel+=3;
 541         }
 542         srcbits = (char*)srcbits + srclinebytes;
 543         dstbits = (char*)dstbits + dstlinebytes;
 544     }
 545 }
 546
 547 static void X11DRV_DIB_Convert_555_to_0888_asis(int width, int height,
 548                                     const void* srcbits, int srclinebytes,
 549                                     void* dstbits, int dstlinebytes)
 550 {
 551     const WORD* srcpixel;
 552     DWORD* dstpixel;
 553     int x,y;
 554
 555     for (y=0; y<height; y++) {
 556         srcpixel=srcbits;
 557         dstpixel=dstbits;
 558         for (x=0; x<width; x++) {
 559             WORD srcval;
 560             srcval=*srcpixel++;
 561             *dstpixel++=((srcval << 9) & 0xf80000) | /* h */
 562                         ((srcval << 4) & 0x070000) | /* h - 3 bits */
 563                         ((srcval << 6) & 0x00f800) | /* g */
 564                         ((srcval << 1) & 0x000700) | /* g - 3 bits */
 565                         ((srcval << 3) & 0x0000f8) | /* l */
 566                         ((srcval >> 2) & 0x000007);  /* l - 3 bits */
 567         }
 568         srcbits = (char*)srcbits + srclinebytes;
 569         dstbits = (char*)dstbits + dstlinebytes;
 570     }
 571 }
 572
 573 static void X11DRV_DIB_Convert_555_to_0888_reverse(int width, int height,
 574                                     const void* srcbits, int srclinebytes,
 575                                     void* dstbits, int dstlinebytes)
 576 {
 577     const WORD* srcpixel;
 578     DWORD* dstpixel;
 579     int x,y;
 580
 581     for (y=0; y<height; y++) {
 582         srcpixel=srcbits;
 583         dstpixel=dstbits;
 584         for (x=0; x<width; x++) {
 585             WORD srcval;
 586             srcval=*srcpixel++;
 587             *dstpixel++=((srcval >>  7) & 0x0000f8) | /* h */
 588                         ((srcval >> 12) & 0x000007) | /* h - 3 bits */
 589                         ((srcval <<  6) & 0x00f800) | /* g */
 590                         ((srcval <<  1) & 0x000700) | /* g - 3 bits */
 591                         ((srcval << 19) & 0xf80000) | /* l */
 592                         ((srcval << 14) & 0x070000);  /* l - 3 bits */
 593         }
 594         srcbits = (char*)srcbits + srclinebytes;
 595         dstbits = (char*)dstbits + dstlinebytes;
 596     }
 597 }
 598
 599 static void X11DRV_DIB_Convert_5x5_to_any0888(int width, int height,
 600                                     const void* srcbits, int srclinebytes,
 601                                     WORD rsrc, WORD gsrc, WORD bsrc,
 602                                     void* dstbits, int dstlinebytes,
 603                                     DWORD rdst, DWORD gdst, DWORD bdst)
 604 {
 605     int rRightShift1,gRightShift1,bRightShift1;
 606     int rRightShift2,gRightShift2,bRightShift2;
 607     BYTE gMask1,gMask2;
 608     int rLeftShift,gLeftShift,bLeftShift;
 609     const WORD* srcpixel;
 610     DWORD* dstpixel;
 611     int x,y;
 612
 613     /* Note, the source pixel value is shifted left by 16 bits so that
 614      * we know we will always have to shift right to extract the components.
 615      */
 616     rRightShift1=16+X11DRV_DIB_MaskToShift(rsrc)-3;
 617     gRightShift1=16+X11DRV_DIB_MaskToShift(gsrc)-3;
 618     bRightShift1=16+X11DRV_DIB_MaskToShift(bsrc)-3;
 619     rRightShift2=rRightShift1+5;
 620     gRightShift2=gRightShift1+5;
 621     bRightShift2=bRightShift1+5;
 622     if (gsrc==0x03e0) {
 623         /* Green has 5 bits, like the others */
 624         gMask1=0xf8;
 625         gMask2=0x07;
 626     } else {
 627         /* Green has 6 bits, not 5. Compensate. */
 628         gRightShift1++;
 629         gRightShift2+=2;
 630         gMask1=0xfc;
 631         gMask2=0x03;
 632     }
 633
 634     rLeftShift=X11DRV_DIB_MaskToShift(rdst);
 635     gLeftShift=X11DRV_DIB_MaskToShift(gdst);
 636     bLeftShift=X11DRV_DIB_MaskToShift(bdst);
 637
 638     for (y=0; y<height; y++) {
 639         srcpixel=srcbits;
 640         dstpixel=dstbits;
 641         for (x=0; x<width; x++) {
 642             DWORD srcval;
 643             BYTE red,green,blue;
 644             srcval=*srcpixel++ << 16;
 645             red=  ((srcval >> rRightShift1) & 0xf8) |
 646                   ((srcval >> rRightShift2) & 0x07);
 647             green=((srcval >> gRightShift1) & gMask1) |
 648                   ((srcval >> gRightShift2) & gMask2);
 649             blue= ((srcval >> bRightShift1) & 0xf8) |
 650                   ((srcval >> bRightShift2) & 0x07);
 651             *dstpixel++=(red   << rLeftShift) |
 652                         (green << gLeftShift) |
 653                         (blue  << bLeftShift);
 654         }
 655         srcbits = (char*)srcbits + srclinebytes;
 656         dstbits = (char*)dstbits + dstlinebytes;
 657     }
 658 }
 659
 660 /*
 661  * 16 bits conversions
 662  */
 663
 664 static void X11DRV_DIB_Convert_565_reverse(int width, int height,
 665                                     const void* srcbits, int srclinebytes,
 666                                     void* dstbits, int dstlinebytes)
 667 {
 668     const DWORD* srcpixel;
 669     DWORD* dstpixel;
 670     int x,y;
 671
 672     for (y=0; y<height; y++) {
 673         srcpixel=srcbits;
 674         dstpixel=dstbits;
 675         for (x=0; x<width/2; x++) {
 676             /* Do 2 pixels at a time */
 677             DWORD srcval;
 678             srcval=*srcpixel++;
 679             *dstpixel++=((srcval << 11) & 0xf800f800) | /* h */
 680                         ( srcval        & 0x07e007e0) | /* g */
 681                         ((srcval >> 11) & 0x001f001f);  /* l */
 682         }
 683         if (width&1) {
 684             /* And the the odd pixel */
 685             WORD srcval;
 686             srcval=*((WORD*)srcpixel);
 687             *((WORD*)dstpixel)=((srcval << 11) & 0xf800) | /* h */
 688                                ( srcval        & 0x07e0) | /* g */
 689                                ((srcval >> 11) & 0x001f);  /* l */
 690         }
 691         srcbits = (char*)srcbits + srclinebytes;
 692         dstbits = (char*)dstbits + dstlinebytes;
 693     }
 694 }
 695
 696 static void X11DRV_DIB_Convert_565_to_555_asis(int width, int height,
 697                                     const void* srcbits, int srclinebytes,
 698                                     void* dstbits, int dstlinebytes)
 699 {
 700     const DWORD* srcpixel;
 701     DWORD* dstpixel;
 702     int x,y;
 703
 704     for (y=0; y<height; y++) {
 705         srcpixel=srcbits;
 706         dstpixel=dstbits;
 707         for (x=0; x<width/2; x++) {
 708             /* Do 2 pixels at a time */
 709             DWORD srcval;
 710             srcval=*srcpixel++;
 711             *dstpixel++=((srcval >> 1) & 0x7fe07fe0) | /* h, g */
 712                         ( srcval       & 0x001f001f);  /* l */
 713         }
 714         if (width&1) {
 715             /* And the the odd pixel */
 716             WORD srcval;
 717             srcval=*((WORD*)srcpixel);
 718             *((WORD*)dstpixel)=((srcval >> 1) & 0x7fe0) | /* h, g */
 719                                ( srcval       & 0x001f);  /* l */
 720         }
 721         srcbits = (char*)srcbits + srclinebytes;
 722         dstbits = (char*)dstbits + dstlinebytes;
 723     }
 724 }
 725
 726 static void X11DRV_DIB_Convert_565_to_555_reverse(int width, int height,
 727                                     const void* srcbits, int srclinebytes,
 728                                     void* dstbits, int dstlinebytes)
 729 {
 730     const DWORD* srcpixel;
 731     DWORD* dstpixel;
 732     int x,y;
 733
 734     for (y=0; y<height; y++) {
 735         srcpixel=srcbits;
 736         dstpixel=dstbits;
 737         for (x=0; x<width/2; x++) {
 738             /* Do 2 pixels at a time */
 739             DWORD srcval;
 740             srcval=*srcpixel++;
 741             *dstpixel++=((srcval >> 11) & 0x001f001f) | /* h */
 742                         ((srcval >>  1) & 0x03e003e0) | /* g */
 743                         ((srcval << 10) & 0x7c007c00);  /* l */
 744         }
 745         if (width&1) {
 746             /* And the the odd pixel */
 747             WORD srcval;
 748             srcval=*((WORD*)srcpixel);
 749             *((WORD*)dstpixel)=((srcval >> 11) & 0x001f) | /* h */
 750                                ((srcval >>  1) & 0x03e0) | /* g */
 751                                ((srcval << 10) & 0x7c00);  /* l */
 752         }
 753         srcbits = (char*)srcbits + srclinebytes;
 754         dstbits = (char*)dstbits + dstlinebytes;
 755     }
 756 }
 757
 758 static void X11DRV_DIB_Convert_565_to_888_asis(int width, int height,
 759                                     const void* srcbits, int srclinebytes,
 760                                     void* dstbits, int dstlinebytes)
 761 {
 762     const WORD* srcpixel;
 763     BYTE* dstpixel;
 764     int x,y;
 765
 766     for (y=0; y<height; y++) {
 767         srcpixel=srcbits;
 768         dstpixel=dstbits;
 769         for (x=0; x<width; x++) {
 770             WORD srcval;
 771             srcval=*srcpixel++;
 772             dstpixel[0]=((srcval <<  3) & 0xf8) | /* l */
 773                         ((srcval >>  2) & 0x07);  /* l - 3 bits */
 774             dstpixel[1]=((srcval >>  3) & 0xfc) | /* g */
 775                         ((srcval >>  9) & 0x03);  /* g - 2 bits */
 776             dstpixel[2]=((srcval >>  8) & 0xf8) | /* h */
 777                         ((srcval >> 13) & 0x07);  /* h - 3 bits */
 778             dstpixel+=3;
 779         }
 780         srcbits = (char*)srcbits + srclinebytes;
 781         dstbits = (char*)dstbits + dstlinebytes;
 782     }
 783 }
 784
 785 static void X11DRV_DIB_Convert_565_to_888_reverse(int width, int height,
 786                                     const void* srcbits, int srclinebytes,
 787                                     void* dstbits, int dstlinebytes)
 788 {
 789     const WORD* srcpixel;
 790     BYTE* dstpixel;
 791     int x,y;
 792
 793     for (y=0; y<height; y++) {
 794         srcpixel=srcbits;
 795         dstpixel=dstbits;
 796         for (x=0; x<width; x++) {
 797             WORD srcval;
 798             srcval=*srcpixel++;
 799             dstpixel[0]=((srcval >>  8) & 0xf8) | /* h */
 800                         ((srcval >> 13) & 0x07);  /* h - 3 bits */
 801             dstpixel[1]=((srcval >>  3) & 0xfc) | /* g */
 802                         ((srcval >>  9) & 0x03);  /* g - 2 bits */
 803             dstpixel[2]=((srcval <<  3) & 0xf8) | /* l */
 804                         ((srcval >>  2) & 0x07);  /* l - 3 bits */
 805             dstpixel+=3;
 806         }
 807         srcbits = (char*)srcbits + srclinebytes;
 808         dstbits = (char*)dstbits + dstlinebytes;
 809     }
 810 }
 811
 812 static void X11DRV_DIB_Convert_565_to_0888_asis(int width, int height,
 813                                     const void* srcbits, int srclinebytes,
 814                                     void* dstbits, int dstlinebytes)
 815 {
 816     const WORD* srcpixel;
 817     DWORD* dstpixel;
 818     int x,y;
 819
 820     for (y=0; y<height; y++) {
 821         srcpixel=srcbits;
 822         dstpixel=dstbits;
 823         for (x=0; x<width; x++) {
 824             WORD srcval;
 825             srcval=*srcpixel++;
 826             *dstpixel++=((srcval << 8) & 0xf80000) | /* h */
 827                         ((srcval << 3) & 0x070000) | /* h - 3 bits */
 828                         ((srcval << 5) & 0x00fc00) | /* g */
 829                         ((srcval >> 1) & 0x000300) | /* g - 2 bits */
 830                         ((srcval << 3) & 0x0000f8) | /* l */
 831                         ((srcval >> 2) & 0x000007);  /* l - 3 bits */
 832         }
 833         srcbits = (char*)srcbits + srclinebytes;
 834         dstbits = (char*)dstbits + dstlinebytes;
 835     }
 836 }
 837
 838 static void X11DRV_DIB_Convert_565_to_0888_reverse(int width, int height,
 839                                     const void* srcbits, int srclinebytes,
 840                                     void* dstbits, int dstlinebytes)
 841 {
 842     const WORD* srcpixel;
 843     DWORD* dstpixel;
 844     int x,y;
 845
 846     for (y=0; y<height; y++) {
 847         srcpixel=srcbits;
 848         dstpixel=dstbits;
 849         for (x=0; x<width; x++) {
 850             WORD srcval;
 851             srcval=*srcpixel++;
 852             *dstpixel++=((srcval >>  8) & 0x0000f8) | /* h */
 853                         ((srcval >> 13) & 0x000007) | /* h - 3 bits */
 854                         ((srcval <<  5) & 0x00fc00) | /* g */
 855                         ((srcval >>  1) & 0x000300) | /* g - 2 bits */
 856                         ((srcval << 19) & 0xf80000) | /* l */
 857                         ((srcval << 14) & 0x070000);  /* l - 3 bits */
 858         }
 859         srcbits = (char*)srcbits + srclinebytes;
 860         dstbits = (char*)dstbits + dstlinebytes;
 861     }
 862 }
 863
 864 /*
 865  * 24 bit conversions
 866  */
 867
 868 static void X11DRV_DIB_Convert_888_reverse(int width, int height,
 869                                     const void* srcbits, int srclinebytes,
 870                                     void* dstbits, int dstlinebytes)
 871 {
 872     const BYTE* srcpixel;
 873     BYTE* dstpixel;
 874     int x,y;
 875
 876     for (y=0; y<height; y++) {
 877         srcpixel=srcbits;
 878         dstpixel=dstbits;
 879         for (x=0; x<width; x++) {
 880             dstpixel[0]=srcpixel[2];
 881             dstpixel[1]=srcpixel[1];
 882             dstpixel[2]=srcpixel[0];
 883             srcpixel+=3;
 884             dstpixel+=3;
 885         }
 886         srcbits = (char*)srcbits + srclinebytes;
 887         dstbits = (char*)dstbits + dstlinebytes;
 888     }
 889 }
 890
 891 static void X11DRV_DIB_Convert_888_to_555_asis(int width, int height,
 892                                     const void* srcbits, int srclinebytes,
 893                                     void* dstbits, int dstlinebytes)
 894 {
 895     const DWORD* srcpixel;
 896     const BYTE* srcbyte;
 897     WORD* dstpixel;
 898     int x,y;
 899     int oddwidth;
 900
 901     oddwidth=width & 3;
 902     width=width/4;
 903     for (y=0; y<height; y++) {
 904         srcpixel=srcbits;
 905         dstpixel=dstbits;
 906         for (x=0; x<width; x++) {
 907             /* Do 4 pixels at a time: 3 dwords in and 4 words out */
 908             DWORD srcval1,srcval2;
 909             srcval1=srcpixel[0];
 910             dstpixel[0]=((srcval1 >>  3) & 0x001f) | /* l1 */
 911                         ((srcval1 >>  6) & 0x03e0) | /* g1 */
 912                         ((srcval1 >>  9) & 0x7c00);  /* h1 */
 913             srcval2=srcpixel[1];
 914             dstpixel[1]=((srcval1 >> 27) & 0x001f) | /* l2 */
 915                         ((srcval2 <<  2) & 0x03e0) | /* g2 */
 916                         ((srcval2 >>  1) & 0x7c00);  /* h2 */
 917             srcval1=srcpixel[2];
 918             dstpixel[2]=((srcval2 >> 19) & 0x001f) | /* l3 */
 919                         ((srcval2 >> 22) & 0x03e0) | /* g3 */
 920                         ((srcval1 <<  7) & 0x7c00);  /* h3 */
 921             dstpixel[3]=((srcval1 >> 11) & 0x001f) | /* l4 */
 922                         ((srcval1 >> 14) & 0x03e0) | /* g4 */
 923                         ((srcval1 >> 17) & 0x7c00);  /* h4 */
 924             srcpixel+=3;
 925             dstpixel+=4;
 926         }
 927         /* And now up to 3 odd pixels */
 928         srcbyte=(LPBYTE)srcpixel;
 929         for (x=0; x<oddwidth; x++) {
 930             WORD dstval;
 931             dstval =((srcbyte[0] >> 3) & 0x001f);    /* l */
 932             dstval|=((srcbyte[1] << 2) & 0x03e0);    /* g */
 933             dstval|=((srcbyte[2] << 7) & 0x7c00);    /* h */
 934             *dstpixel++=dstval;
 935             srcbyte+=3;
 936         }
 937         srcbits = (char*)srcbits + srclinebytes;
 938         dstbits = (char*)dstbits + dstlinebytes;
 939     }
 940 }
 941
 942 static void X11DRV_DIB_Convert_888_to_555_reverse(int width, int height,
 943                                     const void* srcbits, int srclinebytes,
 944                                     void* dstbits, int dstlinebytes)
 945 {
 946     const DWORD* srcpixel;
 947     const BYTE* srcbyte;
 948     WORD* dstpixel;
 949     int x,y;
 950     int oddwidth;
 951
 952     oddwidth=width & 3;
 953     width=width/4;
 954     for (y=0; y<height; y++) {
 955         srcpixel=srcbits;
 956         dstpixel=dstbits;
 957         for (x=0; x<width; x++) {
 958             /* Do 4 pixels at a time: 3 dwords in and 4 words out */
 959             DWORD srcval1,srcval2;
 960             srcval1=srcpixel[0];
 961             dstpixel[0]=((srcval1 <<  7) & 0x7c00) | /* l1 */
 962                         ((srcval1 >>  6) & 0x03e0) | /* g1 */
 963                         ((srcval1 >> 19) & 0x001f);  /* h1 */
 964             srcval2=srcpixel[1];
 965             dstpixel[1]=((srcval1 >> 17) & 0x7c00) | /* l2 */
 966                         ((srcval2 <<  2) & 0x03e0) | /* g2 */
 967                         ((srcval2 >> 11) & 0x001f);  /* h2 */
 968             srcval1=srcpixel[2];
 969             dstpixel[2]=((srcval2 >>  9) & 0x7c00) | /* l3 */
 970                         ((srcval2 >> 22) & 0x03e0) | /* g3 */
 971                         ((srcval1 >>  3) & 0x001f);  /* h3 */
 972             dstpixel[3]=((srcval1 >>  1) & 0x7c00) | /* l4 */
 973                         ((srcval1 >> 14) & 0x03e0) | /* g4 */
 974                         ((srcval1 >> 27) & 0x001f);  /* h4 */
 975             srcpixel+=3;
 976             dstpixel+=4;
 977         }
 978         /* And now up to 3 odd pixels */
 979         srcbyte=(LPBYTE)srcpixel;
 980         for (x=0; x<oddwidth; x++) {
 981             WORD dstval;
 982             dstval =((srcbyte[0] << 7) & 0x7c00);    /* l */
 983             dstval|=((srcbyte[1] << 2) & 0x03e0);    /* g */
 984             dstval|=((srcbyte[2] >> 3) & 0x001f);    /* h */
 985             *dstpixel++=dstval;
 986             srcbyte+=3;
 987         }
 988         srcbits = (char*)srcbits + srclinebytes;
 989         dstbits = (char*)dstbits + dstlinebytes;
 990     }
 991 }
 992
 993 static void X11DRV_DIB_Convert_888_to_565_asis(int width, int height,
 994                                     const void* srcbits, int srclinebytes,
 995                                     void* dstbits, int dstlinebytes)
 996 {
 997     const DWORD* srcpixel;
 998     const BYTE* srcbyte;
 999     WORD* dstpixel;
1000     int x,y;
1001     int oddwidth;
1002
1003     oddwidth=width & 3;
1004     width=width/4;
1005     for (y=0; y<height; y++) {
1006         srcpixel=srcbits;
1007         dstpixel=dstbits;
1008         for (x=0; x<width; x++) {
1009             /* Do 4 pixels at a time: 3 dwords in and 4 words out */
1010             DWORD srcval1,srcval2;
1011             srcval1=srcpixel[0];
1012             dstpixel[0]=((srcval1 >>  3) & 0x001f) | /* l1 */
1013                         ((srcval1 >>  5) & 0x07e0) | /* g1 */
1014                         ((srcval1 >>  8) & 0xf800);  /* h1 */
1015             srcval2=srcpixel[1];
1016             dstpixel[1]=((srcval1 >> 27) & 0x001f) | /* l2 */
1017                         ((srcval2 <<  3) & 0x07e0) | /* g2 */
1018                         ( srcval2        & 0xf800);  /* h2 */
1019             srcval1=srcpixel[2];
1020             dstpixel[2]=((srcval2 >> 19) & 0x001f) | /* l3 */
1021                         ((srcval2 >> 21) & 0x07e0) | /* g3 */
1022                         ((srcval1 <<  8) & 0xf800);  /* h3 */
1023             dstpixel[3]=((srcval1 >> 11) & 0x001f) | /* l4 */
1024                         ((srcval1 >> 13) & 0x07e0) | /* g4 */
1025                         ((srcval1 >> 16) & 0xf800);  /* h4 */
1026             srcpixel+=3;
1027             dstpixel+=4;
1028         }
1029         /* And now up to 3 odd pixels */
1030         srcbyte=(LPBYTE)srcpixel;
1031         for (x=0; x<oddwidth; x++) {
1032             WORD dstval;
1033             dstval =((srcbyte[0] >> 3) & 0x001f);    /* l */
1034             dstval|=((srcbyte[1] << 3) & 0x07e0);    /* g */
1035             dstval|=((srcbyte[2] << 8) & 0xf800);    /* h */
1036             *dstpixel++=dstval;
1037             srcbyte+=3;
1038         }
1039         srcbits = (char*)srcbits + srclinebytes;
1040         dstbits = (char*)dstbits + dstlinebytes;
1041     }
1042 }
1043
1044 static void X11DRV_DIB_Convert_888_to_565_reverse(int width, int height,
1045                                     const void* srcbits, int srclinebytes,
1046                                     void* dstbits, int dstlinebytes)
1047 {
1048     const DWORD* srcpixel;
1049     const BYTE* srcbyte;
1050     WORD* dstpixel;
1051     int x,y;
1052     int oddwidth;
1053
1054     oddwidth=width & 3;
1055     width=width/4;
1056     for (y=0; y<height; y++) {
1057         srcpixel=srcbits;
1058         dstpixel=dstbits;
1059         for (x=0; x<width; x++) {
1060             /* Do 4 pixels at a time: 3 dwords in and 4 words out */
1061             DWORD srcval1,srcval2;
1062             srcval1=srcpixel[0];
1063             dstpixel[0]=((srcval1 <<  8) & 0xf800) | /* l1 */
1064                         ((srcval1 >>  5) & 0x07e0) | /* g1 */
1065                         ((srcval1 >> 19) & 0x001f);  /* h1 */
1066             srcval2=srcpixel[1];
1067             dstpixel[1]=((srcval1 >> 16) & 0xf800) | /* l2 */
1068                         ((srcval2 <<  3) & 0x07e0) | /* g2 */
1069                         ((srcval2 >> 11) & 0x001f);  /* h2 */
1070             srcval1=srcpixel[2];
1071             dstpixel[2]=((srcval2 >>  8) & 0xf800) | /* l3 */
1072                         ((srcval2 >> 21) & 0x07e0) | /* g3 */
1073                         ((srcval1 >>  3) & 0x001f);  /* h3 */
1074             dstpixel[3]=(srcval1         & 0xf800) | /* l4 */
1075                         ((srcval1 >> 13) & 0x07e0) | /* g4 */
1076                         ((srcval1 >> 27) & 0x001f);  /* h4 */
1077             srcpixel+=3;
1078             dstpixel+=4;
1079         }
1080         /* And now up to 3 odd pixels */
1081         srcbyte=(LPBYTE)srcpixel;
1082         for (x=0; x<oddwidth; x++) {
1083             WORD dstval;
1084             dstval =((srcbyte[0] << 8) & 0xf800);    /* l */
1085             dstval|=((srcbyte[1] << 3) & 0x07e0);    /* g */
1086             dstval|=((srcbyte[2] >> 3) & 0x001f);    /* h */
1087             *dstpixel++=dstval;
1088             srcbyte+=3;
1089         }
1090         srcbits = (char*)srcbits + srclinebytes;
1091         dstbits = (char*)dstbits + dstlinebytes;
1092     }
1093 }
1094
1095 static void X11DRV_DIB_Convert_888_to_0888_asis(int width, int height,
1096                                     const void* srcbits, int srclinebytes,
1097                                     void* dstbits, int dstlinebytes)
1098 {
1099     const DWORD* srcpixel;
1100     DWORD* dstpixel;
1101     int x,y;
1102     int oddwidth;
1103
1104     oddwidth=width & 3;
1105     width=width/4;
1106     for (y=0; y<height; y++) {
1107         srcpixel=srcbits;
1108         dstpixel=dstbits;
1109         for (x=0; x<width; x++) {
1110             /* Do 4 pixels at a time: 3 dwords in and 4 dwords out */
1111             DWORD srcval1,srcval2;
1112             srcval1=srcpixel[0];
1113             dstpixel[0]=( srcval1        & 0x00ffffff);  /* h1, g1, l1 */
1114             srcval2=srcpixel[1];
1115             dstpixel[1]=( srcval1 >> 24) |              /* l2 */
1116                         ((srcval2 <<  8) & 0x00ffff00); /* h2, g2 */
1117             srcval1=srcpixel[2];
1118             dstpixel[2]=( srcval2 >> 16) |              /* g3, l3 */
1119                         ((srcval1 << 16) & 0x00ff0000); /* h3 */
1120             dstpixel[3]=( srcval1 >>  8);               /* h4, g4, l4 */
1121             srcpixel+=3;
1122             dstpixel+=4;
1123         }
1124         /* And now up to 3 odd pixels */
1125         for (x=0; x<oddwidth; x++) {
1126             DWORD srcval;
1127             srcval=*srcpixel;
1128             srcpixel=(LPDWORD)(((char*)srcpixel)+3);
1129             *dstpixel++=( srcval         & 0x00ffffff); /* h, g, l */
1130         }
1131         srcbits = (char*)srcbits + srclinebytes;
1132         dstbits = (char*)dstbits + dstlinebytes;
1133     }
1134 }
1135
1136 static void X11DRV_DIB_Convert_888_to_0888_reverse(int width, int height,
1137                                     const void* srcbits, int srclinebytes,
1138                                     void* dstbits, int dstlinebytes)
1139 {
1140     const DWORD* srcpixel;
1141     DWORD* dstpixel;
1142     int x,y;
1143     int oddwidth;
1144
1145     oddwidth=width & 3;
1146     width=width/4;
1147     for (y=0; y<height; y++) {
1148         srcpixel=srcbits;
1149         dstpixel=dstbits;
1150         for (x=0; x<width; x++) {
1151             /* Do 4 pixels at a time: 3 dwords in and 4 dwords out */
1152             DWORD srcval1,srcval2;
1153
1154             srcval1=srcpixel[0];
1155             dstpixel[0]=((srcval1 >> 16) & 0x0000ff) | /* h1 */
1156                         ( srcval1        & 0x00ff00) | /* g1 */
1157                         ((srcval1 << 16) & 0xff0000);  /* l1 */
1158             srcval2=srcpixel[1];
1159             dstpixel[1]=((srcval1 >>  8) & 0xff0000) | /* l2 */
1160                         ((srcval2 <<  8) & 0x00ff00) | /* g2 */
1161                         ((srcval2 >>  8) & 0x0000ff);  /* h2 */
1162             srcval1=srcpixel[2];
1163             dstpixel[2]=( srcval2        & 0xff0000) | /* l3 */
1164                         ((srcval2 >> 16) & 0x00ff00) | /* g3 */
1165                         ( srcval1        & 0x0000ff);  /* h3 */
1166             dstpixel[3]=((srcval1 >> 24) & 0x0000ff) | /* h4 */
1167                         ((srcval1 >>  8) & 0x00ff00) | /* g4 */
1168                         ((srcval1 <<  8) & 0xff0000);  /* l4 */
1169             srcpixel+=3;
1170             dstpixel+=4;
1171         }
1172         /* And now up to 3 odd pixels */
1173         for (x=0; x<oddwidth; x++) {
1174             DWORD srcval;
1175             srcval=*srcpixel;
1176             srcpixel=(LPDWORD)(((char*)srcpixel)+3);
1177             *dstpixel++=((srcval  >> 16) & 0x0000ff) | /* h */
1178                         ( srcval         & 0x00ff00) | /* g */
1179                         ((srcval  << 16) & 0xff0000);  /* l */
1180         }
1181         srcbits = (char*)srcbits + srclinebytes;
1182         dstbits = (char*)dstbits + dstlinebytes;
1183     }
1184 }
1185
1186 static void X11DRV_DIB_Convert_rgb888_to_any0888(int width, int height,
1187                                     const void* srcbits, int srclinebytes,
1188                                     void* dstbits, int dstlinebytes,
1189                                     DWORD rdst, DWORD gdst, DWORD bdst)
1190 {
1191     int rLeftShift,gLeftShift,bLeftShift;
1192     const BYTE* srcpixel;
1193     DWORD* dstpixel;
1194     int x,y;
1195
1196     rLeftShift=X11DRV_DIB_MaskToShift(rdst);
1197     gLeftShift=X11DRV_DIB_MaskToShift(gdst);
1198     bLeftShift=X11DRV_DIB_MaskToShift(bdst);
1199     for (y=0; y<height; y++) {
1200         srcpixel=srcbits;
1201         dstpixel=dstbits;
1202         for (x=0; x<width; x++) {
1203             *dstpixel++=(srcpixel[0] << bLeftShift) | /* b */
1204                         (srcpixel[1] << gLeftShift) | /* g */
1205                         (srcpixel[2] << rLeftShift);  /* r */
1206             srcpixel+=3;
1207         }
1208         srcbits = (char*)srcbits + srclinebytes;
1209         dstbits = (char*)dstbits + dstlinebytes;
1210     }
1211 }
1212
1213 static void X11DRV_DIB_Convert_bgr888_to_any0888(int width, int height,
1214                                     const void* srcbits, int srclinebytes,
1215                                     void* dstbits, int dstlinebytes,
1216                                     DWORD rdst, DWORD gdst, DWORD bdst)
1217 {
1218     int rLeftShift,gLeftShift,bLeftShift;
1219     const BYTE* srcpixel;
1220     DWORD* dstpixel;
1221     int x,y;
1222
1223     rLeftShift=X11DRV_DIB_MaskToShift(rdst);
1224     gLeftShift=X11DRV_DIB_MaskToShift(gdst);
1225     bLeftShift=X11DRV_DIB_MaskToShift(bdst);
1226     for (y=0; y<height; y++) {
1227         srcpixel=srcbits;
1228         dstpixel=dstbits;
1229         for (x=0; x<width; x++) {
1230             *dstpixel++=(srcpixel[0] << rLeftShift) | /* r */
1231                         (srcpixel[1] << gLeftShift) | /* g */
1232                         (srcpixel[2] << bLeftShift);  /* b */
1233             srcpixel+=3;
1234         }
1235         srcbits = (char*)srcbits + srclinebytes;
1236         dstbits = (char*)dstbits + dstlinebytes;
1237     }
1238 }
1239
1240 /*
1241  * 32 bit conversions
1242  */
1243
1244 static void X11DRV_DIB_Convert_0888_reverse(int width, int height,
1245                                     const void* srcbits, int srclinebytes,
1246                                     void* dstbits, int dstlinebytes)
1247 {
1248     const DWORD* srcpixel;
1249     DWORD* dstpixel;
1250     int x,y;
1251
1252     for (y=0; y<height; y++) {
1253         srcpixel=srcbits;
1254         dstpixel=dstbits;
1255         for (x=0; x<width; x++) {
1256             DWORD srcval;
1257             srcval=*srcpixel++;
1258             *dstpixel++=((srcval << 16) & 0x00ff0000) | /* h */
1259                         ( srcval        & 0x0000ff00) | /* g */
1260                         ((srcval >> 16) & 0x000000ff);  /* l */
1261         }
1262         srcbits = (char*)srcbits + srclinebytes;
1263         dstbits = (char*)dstbits + dstlinebytes;
1264     }
1265 }
1266
1267 static void X11DRV_DIB_Convert_0888_any(int width, int height,
1268                                     const void* srcbits, int srclinebytes,
1269                                     DWORD rsrc, DWORD gsrc, DWORD bsrc,
1270                                     void* dstbits, int dstlinebytes,
1271                                     DWORD rdst, DWORD gdst, DWORD bdst)
1272 {
1273     int rRightShift,gRightShift,bRightShift;
1274     int rLeftShift,gLeftShift,bLeftShift;
1275     const DWORD* srcpixel;
1276     DWORD* dstpixel;
1277     int x,y;
1278
1279     rRightShift=X11DRV_DIB_MaskToShift(rsrc);
1280     gRightShift=X11DRV_DIB_MaskToShift(gsrc);
1281     bRightShift=X11DRV_DIB_MaskToShift(bsrc);
1282     rLeftShift=X11DRV_DIB_MaskToShift(rdst);
1283     gLeftShift=X11DRV_DIB_MaskToShift(gdst);
1284     bLeftShift=X11DRV_DIB_MaskToShift(bdst);
1285     for (y=0; y<height; y++) {
1286         srcpixel=srcbits;
1287         dstpixel=dstbits;
1288         for (x=0; x<width; x++) {
1289             DWORD srcval;
1290             srcval=*srcpixel++;
1291             *dstpixel++=(((srcval >> rRightShift) & 0xff) << rLeftShift) |
1292                         (((srcval >> gRightShift) & 0xff) << gLeftShift) |
1293                         (((srcval >> bRightShift) & 0xff) << bLeftShift);
1294         }
1295         srcbits = (char*)srcbits + srclinebytes;
1296         dstbits = (char*)dstbits + dstlinebytes;
1297     }
1298 }
1299
1300 static void X11DRV_DIB_Convert_0888_to_555_asis(int width, int height,
1301                                     const void* srcbits, int srclinebytes,
1302                                     void* dstbits, int dstlinebytes)
1303 {
1304     const DWORD* srcpixel;
1305     WORD* dstpixel;
1306     int x,y;
1307
1308     for (y=0; y<height; y++) {
1309         srcpixel=srcbits;
1310         dstpixel=dstbits;
1311         for (x=0; x<width; x++) {
1312             DWORD srcval;
1313             srcval=*srcpixel++;
1314             *dstpixel++=((srcval >> 9) & 0x7c00) | /* h */
1315                         ((srcval >> 6) & 0x03e0) | /* g */
1316                         ((srcval >> 3) & 0x001f);  /* l */
1317         }
1318         srcbits = (char*)srcbits + srclinebytes;
1319         dstbits = (char*)dstbits + dstlinebytes;
1320     }
1321 }
1322
1323 static void X11DRV_DIB_Convert_0888_to_555_reverse(int width, int height,
1324                                     const void* srcbits, int srclinebytes,
1325                                     void* dstbits, int dstlinebytes)
1326 {
1327     const DWORD* srcpixel;
1328     WORD* dstpixel;
1329     int x,y;
1330
1331     for (y=0; y<height; y++) {
1332         srcpixel=srcbits;
1333         dstpixel=dstbits;
1334         for (x=0; x<width; x++) {
1335             DWORD srcval;
1336             srcval=*srcpixel++;
1337             *dstpixel++=((srcval >> 19) & 0x001f) | /* h */
1338                         ((srcval >>  6) & 0x03e0) | /* g */
1339                         ((srcval <<  7) & 0x7c00);  /* l */
1340         }
1341         srcbits = (char*)srcbits + srclinebytes;
1342         dstbits = (char*)dstbits + dstlinebytes;
1343     }
1344 }
1345
1346 static void X11DRV_DIB_Convert_0888_to_565_asis(int width, int height,
1347                                     const void* srcbits, int srclinebytes,
1348                                     void* dstbits, int dstlinebytes)
1349 {
1350     const DWORD* srcpixel;
1351     WORD* dstpixel;
1352     int x,y;
1353
1354     for (y=0; y<height; y++) {
1355         srcpixel=srcbits;
1356         dstpixel=dstbits;
1357         for (x=0; x<width; x++) {
1358             DWORD srcval;
1359             srcval=*srcpixel++;
1360             *dstpixel++=((srcval >> 8) & 0xf800) | /* h */
1361                         ((srcval >> 5) & 0x07e0) | /* g */
1362                         ((srcval >> 3) & 0x001f);  /* l */
1363         }
1364         srcbits = (char*)srcbits + srclinebytes;
1365         dstbits = (char*)dstbits + dstlinebytes;
1366     }
1367 }
1368
1369 static void X11DRV_DIB_Convert_0888_to_565_reverse(int width, int height,
1370                                     const void* srcbits, int srclinebytes,
1371                                     void* dstbits, int dstlinebytes)
1372 {
1373     const DWORD* srcpixel;
1374     WORD* dstpixel;
1375     int x,y;
1376
1377     for (y=0; y<height; y++) {
1378         srcpixel=srcbits;
1379         dstpixel=dstbits;
1380         for (x=0; x<width; x++) {
1381             DWORD srcval;
1382             srcval=*srcpixel++;
1383             *dstpixel++=((srcval >> 19) & 0x001f) | /* h */
1384                         ((srcval >>  5) & 0x07e0) | /* g */
1385                         ((srcval <<  8) & 0xf800);  /* l */
1386         }
1387         srcbits = (char*)srcbits + srclinebytes;
1388         dstbits = (char*)dstbits + dstlinebytes;
1389     }
1390 }
1391
1392 static void X11DRV_DIB_Convert_any0888_to_5x5(int width, int height,
1393                                     const void* srcbits, int srclinebytes,
1394                                     DWORD rsrc, DWORD gsrc, DWORD bsrc,
1395                                     void* dstbits, int dstlinebytes,
1396                                     WORD rdst, WORD gdst, WORD bdst)
1397 {
1398     int rRightShift,gRightShift,bRightShift;
1399     int rLeftShift,gLeftShift,bLeftShift;
1400     const DWORD* srcpixel;
1401     WORD* dstpixel;
1402     int x,y;
1403
1404     /* Here is how we proceed. Assume we have rsrc=0x0000ff00 and our pixel
1405      * contains 0x11223344.
1406      * - first we shift 0x11223344 right by rRightShift to bring the most
1407      *   significant bits of the red components in the bottom 5 (or 6) bits
1408      *   -> 0x4488c
1409      * - then we remove non red bits by anding with the modified rdst (0x1f)
1410      *   -> 0x0c
1411      * - finally shift these bits left by rLeftShift so that they end up in
1412      *   the right place
1413      *   -> 0x3000
1414      */
1415     rRightShift=X11DRV_DIB_MaskToShift(rsrc)+3;
1416     gRightShift=X11DRV_DIB_MaskToShift(gsrc);
1417     gRightShift+=(gdst==0x07e0?2:3);
1418     bRightShift=X11DRV_DIB_MaskToShift(bsrc)+3;
1419
1420     rLeftShift=X11DRV_DIB_MaskToShift(rdst);
1421     rdst=rdst >> rLeftShift;
1422     gLeftShift=X11DRV_DIB_MaskToShift(gdst);
1423     gdst=gdst >> gLeftShift;
1424     bLeftShift=X11DRV_DIB_MaskToShift(bdst);
1425     bdst=bdst >> bLeftShift;
1426
1427     for (y=0; y<height; y++) {
1428         srcpixel=srcbits;
1429         dstpixel=dstbits;
1430         for (x=0; x<width; x++) {
1431             DWORD srcval;
1432             srcval=*srcpixel++;
1433             *dstpixel++=(((srcval >> rRightShift) & rdst) << rLeftShift) |
1434                         (((srcval >> gRightShift) & gdst) << gLeftShift) |
1435                         (((srcval >> bRightShift) & bdst) << bLeftShift);
1436         }
1437         srcbits = (char*)srcbits + srclinebytes;
1438         dstbits = (char*)dstbits + dstlinebytes;
1439     }
1440 }
1441
1442 static void X11DRV_DIB_Convert_0888_to_888_asis(int width, int height,
1443                                     const void* srcbits, int srclinebytes,
1444                                     void* dstbits, int dstlinebytes)
1445 {
1446     const DWORD* srcpixel;
1447     DWORD* dstpixel;
1448     BYTE* dstbyte;
1449     int x,y;
1450     int oddwidth;
1451
1452     oddwidth=width & 3;
1453     width=width/4;
1454     for (y=0; y<height; y++) {
1455         srcpixel=srcbits;
1456         dstpixel=dstbits;
1457         for (x=0; x<width; x++) {
1458             /* Do 4 pixels at a time: 4 dwords in and 3 dwords out */
1459             DWORD srcval;
1460             srcval=((*srcpixel++)       & 0x00ffffff);  /* h1, g1, l1*/
1461             *dstpixel++=srcval | ((*srcpixel)   << 24); /* h2 */
1462             srcval=((*srcpixel++ >> 8 ) & 0x0000ffff);  /* g2, l2 */
1463             *dstpixel++=srcval | ((*srcpixel)   << 16); /* h3, g3 */
1464             srcval=((*srcpixel++ >> 16) & 0x000000ff);  /* l3 */
1465             *dstpixel++=srcval | ((*srcpixel++) << 8);  /* h4, g4, l4 */
1466         }
1467         /* And now up to 3 odd pixels */
1468         dstbyte=(BYTE*)dstpixel;
1469         for (x=0; x<oddwidth; x++) {
1470             DWORD srcval;
1471             srcval=*srcpixel++;
1472             *((WORD*)dstbyte)++=srcval;                 /* h, g */
1473             *dstbyte++=srcval >> 16;                    /* l */
1474         }
1475         srcbits = (char*)srcbits + srclinebytes;
1476         dstbits = (char*)dstbits + dstlinebytes;
1477     }
1478 }
1479
1480 static void X11DRV_DIB_Convert_0888_to_888_reverse(int width, int height,
1481                                     const void* srcbits, int srclinebytes,
1482                                     void* dstbits, int dstlinebytes)
1483 {
1484     const DWORD* srcpixel;
1485     DWORD* dstpixel;
1486     BYTE* dstbyte;
1487     int x,y;
1488     int oddwidth;
1489
1490     oddwidth=width & 3;
1491     width=width/4;
1492     for (y=0; y<height; y++) {
1493         srcpixel=srcbits;
1494         dstpixel=dstbits;
1495         for (x=0; x<width; x++) {
1496             /* Do 4 pixels at a time: 4 dwords in and 3 dwords out */
1497             DWORD srcval1,srcval2;
1498             srcval1=*srcpixel++;
1499             srcval2=    ((srcval1 >> 16) & 0x000000ff) | /* h1 */
1500                         ( srcval1        & 0x0000ff00) | /* g1 */
1501                         ((srcval1 << 16) & 0x00ff0000);  /* l1 */
1502             srcval1=*srcpixel++;
1503             *dstpixel++=srcval2 |
1504                         ((srcval1 <<  8) & 0xff000000);  /* h2 */
1505             srcval2=    ((srcval1 >>  8) & 0x000000ff) | /* g2 */
1506                         ((srcval1 <<  8) & 0x0000ff00);  /* l2 */
1507             srcval1=*srcpixel++;
1508             *dstpixel++=srcval2 |
1509                         ( srcval1        & 0x00ff0000) | /* h3 */
1510                         ((srcval1 << 16) & 0xff000000);  /* g3 */
1511             srcval2=    ( srcval1        & 0x000000ff);  /* l3 */
1512             srcval1=*srcpixel++;
1513             *dstpixel++=srcval2 |
1514                         ((srcval1 >>  8) & 0x0000ff00) | /* h4 */
1515                         ((srcval1 <<  8) & 0x00ff0000) | /* g4 */
1516                         ( srcval1 << 24);                /* l4 */
1517         }
1518         /* And now up to 3 odd pixels */
1519         dstbyte=(BYTE*)dstpixel;
1520         for (x=0; x<oddwidth; x++) {
1521             DWORD srcval;
1522             srcval=*srcpixel++;
1523             *((WORD*)dstbyte)++=((srcval >> 16) & 0x00ff) | /* h */
1524                                 (srcval         & 0xff00);  /* g */
1525             *dstbyte++=srcval;                              /* l */
1526         }
1527         srcbits = (char*)srcbits + srclinebytes;
1528         dstbits = (char*)dstbits + dstlinebytes;
1529     }
1530 }
1531
1532 static void X11DRV_DIB_Convert_any0888_to_rgb888(int width, int height,
1533                                     const void* srcbits, int srclinebytes,
1534                                     DWORD rsrc, DWORD gsrc, DWORD bsrc,
1535                                     void* dstbits, int dstlinebytes)
1536 {
1537     int rRightShift,gRightShift,bRightShift;
1538     const DWORD* srcpixel;
1539     BYTE* dstpixel;
1540     int x,y;
1541
1542     rRightShift=X11DRV_DIB_MaskToShift(rsrc);
1543     gRightShift=X11DRV_DIB_MaskToShift(gsrc);
1544     bRightShift=X11DRV_DIB_MaskToShift(bsrc);
1545     for (y=0; y<height; y++) {
1546         srcpixel=srcbits;
1547         dstpixel=dstbits;
1548         for (x=0; x<width; x++) {
1549             DWORD srcval;
1550             srcval=*srcpixel++;
1551             dstpixel[0]=(srcval >> bRightShift); /* b */
1552             dstpixel[1]=(srcval >> gRightShift); /* g */
1553             dstpixel[2]=(srcval >> rRightShift); /* r */
1554             dstpixel+=3;
1555         }
1556         srcbits = (char*)srcbits + srclinebytes;
1557         dstbits = (char*)dstbits + dstlinebytes;
1558     }
1559 }
1560
1561 static void X11DRV_DIB_Convert_any0888_to_bgr888(int width, int height,
1562                                     const void* srcbits, int srclinebytes,
1563                                     DWORD rsrc, DWORD gsrc, DWORD bsrc,
1564                                     void* dstbits, int dstlinebytes)
1565 {
1566     int rRightShift,gRightShift,bRightShift;
1567     const DWORD* srcpixel;
1568     BYTE* dstpixel;
1569     int x,y;
1570
1571     rRightShift=X11DRV_DIB_MaskToShift(rsrc);
1572     gRightShift=X11DRV_DIB_MaskToShift(gsrc);
1573     bRightShift=X11DRV_DIB_MaskToShift(bsrc);
1574     for (y=0; y<height; y++) {
1575         srcpixel=srcbits;
1576         dstpixel=dstbits;
1577         for (x=0; x<width; x++) {
1578             DWORD srcval;
1579             srcval=*srcpixel++;
1580             dstpixel[0]=(srcval >> rRightShift); /* r */
1581             dstpixel[1]=(srcval >> gRightShift); /* g */
1582             dstpixel[2]=(srcval >> bRightShift); /* b */
1583             dstpixel+=3;
1584         }
1585         srcbits = (char*)srcbits + srclinebytes;
1586         dstbits = (char*)dstbits + dstlinebytes;
1587     }
1588 }
1589
1590 /***********************************************************************
1591  *           X11DRV_DIB_SetImageBits_1
1592  *
1593  * SetDIBits for a 1-bit deep DIB.
1594  */
1595 static void X11DRV_DIB_SetImageBits_1( int lines, const BYTE *srcbits,
1596                                 DWORD srcwidth, DWORD dstwidth, int left,
1597                                 int *colors, XImage *bmpImage, DWORD linebytes)
1598 {
1599     int h;
1600     const BYTE* srcbyte;
1601     BYTE srcval, extra;
1602     DWORD i, x;
1603
1604     if (lines < 0 ) {
1605         lines = -lines;
1606         srcbits = srcbits + linebytes * (lines - 1);
1607         linebytes = -linebytes;
1608     }
1609
1610     if ((extra = (left & 7)) != 0) {
1611         left &= ~7;
1612         dstwidth += extra;
1613     }
1614     srcbits += left >> 3;
1615
1616     /* ==== pal 1 dib -> any bmp format ==== */
1617     for (h = lines-1; h >=0; h--) {
1618         srcbyte=srcbits;
1619         /* FIXME: should avoid putting x<left pixels (minor speed issue) */
1620         for (i = dstwidth/8, x = left; i > 0; i--) {
1621             srcval=*srcbyte++;
1622             XPutPixel( bmpImage, x++, h, colors[ srcval >> 7] );
1623             XPutPixel( bmpImage, x++, h, colors[(srcval >> 6) & 1] );
1624             XPutPixel( bmpImage, x++, h, colors[(srcval >> 5) & 1] );
1625             XPutPixel( bmpImage, x++, h, colors[(srcval >> 4) & 1] );
1626             XPutPixel( bmpImage, x++, h, colors[(srcval >> 3) & 1] );
1627             XPutPixel( bmpImage, x++, h, colors[(srcval >> 2) & 1] );
1628             XPutPixel( bmpImage, x++, h, colors[(srcval >> 1) & 1] );
1629             XPutPixel( bmpImage, x++, h, colors[ srcval       & 1] );
1630         }
1631         if (dstwidth % 8){
1632             srcval=*srcbyte;
1633             switch (dstwidth & 7)
1634             {
1635             case 7: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
1636             case 6: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
1637             case 5: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
1638             case 4: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
1639             case 3: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
1640             case 2: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]); srcval<<=1;
1641             case 1: XPutPixel(bmpImage, x++, h, colors[srcval >> 7]);
1642             }
1643         }
1644         srcbits += linebytes;
1645     }
1646 }
1647
1648 /***********************************************************************
1649  *           X11DRV_DIB_GetImageBits_1
1650  *
1651  * GetDIBits for a 1-bit deep DIB.
1652  */
1653 static void X11DRV_DIB_GetImageBits_1( int lines, BYTE *dstbits,
1654                                        DWORD dstwidth, DWORD srcwidth,
1655                                        RGBQUAD *colors, PALETTEENTRY *srccolors,
1656                                 XImage *bmpImage, DWORD linebytes )
1657 {
1658     DWORD x;
1659     int h;
1660
1661     if (lines < 0 ) {
1662         lines = -lines;
1663         dstbits = dstbits + linebytes * (lines - 1);
1664         linebytes = -linebytes;
1665     }
1666
1667     switch (bmpImage->depth)
1668     {
1669     case 1:
1670     case 4:
1671         if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors) {
1672             /* ==== pal 1 or 4 bmp -> pal 1 dib ==== */
1673             BYTE* dstbyte;
1674
1675             for (h=lines-1; h>=0; h--) {
1676                 BYTE dstval;
1677                 dstbyte=dstbits;
1678                 dstval=0;
1679                 for (x=0; x<dstwidth; x++) {
1680                     PALETTEENTRY srcval;
1681                     srcval=srccolors[XGetPixel(bmpImage, x, h)];
1682                     dstval|=(X11DRV_DIB_GetNearestIndex
1683                              (colors, 2,
1684                               srcval.peRed,
1685                               srcval.peGreen,
1686                               srcval.peBlue) << (7 - (x & 7)));
1687                     if ((x&7)==7) {
1688                         *dstbyte++=dstval;
1689                         dstval=0;
1690                     }
1691                 }
1692                 if ((dstwidth&7)!=0) {
1693                     *dstbyte=dstval;
1694                 }
1695                 dstbits += linebytes;
1696             }
1697         } else {
1698             goto notsupported;
1699         }
1700         break;
1701
1702     case 8:
1703         if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors) {
1704             /* ==== pal 8 bmp -> pal 1 dib ==== */
1705             const void* srcbits;
1706             const BYTE* srcpixel;
1707             BYTE* dstbyte;
1708
1709             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1710
1711             for (h=0; h<lines; h++) {
1712                 BYTE dstval;
1713                 srcpixel=srcbits;
1714                 dstbyte=dstbits;
1715                 dstval=0;
1716                 for (x=0; x<dstwidth; x++) {
1717                     PALETTEENTRY srcval;
1718                     srcval=srccolors[(int)*srcpixel++];
1719                     dstval|=(X11DRV_DIB_GetNearestIndex
1720                              (colors, 2,
1721                               srcval.peRed,
1722                               srcval.peGreen,
1723                               srcval.peBlue) << (7-(x&7)) );
1724                     if ((x&7)==7) {
1725                         *dstbyte++=dstval;
1726                         dstval=0;
1727                     }
1728                 }
1729                 if ((dstwidth&7)!=0) {
1730                     *dstbyte=dstval;
1731                 }
1732                 srcbits = (char*)srcbits - bmpImage->bytes_per_line;
1733                 dstbits += linebytes;
1734             }
1735         } else {
1736             goto notsupported;
1737         }
1738         break;
1739
1740     case 15:
1741     case 16:
1742         {
1743             const void* srcbits;
1744             const WORD* srcpixel;
1745             BYTE* dstbyte;
1746
1747             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1748
1749             if (bmpImage->green_mask==0x03e0) {
1750                 if (bmpImage->red_mask==0x7c00) {
1751                     /* ==== rgb 555 bmp -> pal 1 dib ==== */
1752                     for (h=0; h<lines; h++) {
1753                         BYTE dstval;
1754                         srcpixel=srcbits;
1755                         dstbyte=dstbits;
1756                         dstval=0;
1757                         for (x=0; x<dstwidth; x++) {
1758                             WORD srcval;
1759                             srcval=*srcpixel++;
1760                             dstval|=(X11DRV_DIB_GetNearestIndex
1761                                      (colors, 2,
1762                                       ((srcval >>  7) & 0xf8) | /* r */
1763                                       ((srcval >> 12) & 0x07),
1764                                       ((srcval >>  2) & 0xf8) | /* g */
1765                                       ((srcval >>  7) & 0x07),
1766                                       ((srcval <<  3) & 0xf8) | /* b */
1767                                       ((srcval >>  2) & 0x07) ) << (7-(x&7)) );
1768                             if ((x&7)==7) {
1769                                 *dstbyte++=dstval;
1770                                 dstval=0;
1771                             }
1772                         }
1773                         if ((dstwidth&7)!=0) {
1774                             *dstbyte=dstval;
1775                         }
1776                         srcbits = (char*)srcbits - bmpImage->bytes_per_line;
1777                         dstbits += linebytes;
1778                     }
1779                 } else if (bmpImage->blue_mask==0x7c00) {
1780                     /* ==== bgr 555 bmp -> pal 1 dib ==== */
1781                     for (h=0; h<lines; h++) {
1782                         WORD dstval;
1783                         srcpixel=srcbits;
1784                         dstbyte=dstbits;
1785                         dstval=0;
1786                         for (x=0; x<dstwidth; x++) {
1787                             BYTE srcval;
1788                             srcval=*srcpixel++;
1789                             dstval|=(X11DRV_DIB_GetNearestIndex
1790                                      (colors, 2,
1791                                       ((srcval <<  3) & 0xf8) | /* r */
1792                                       ((srcval >>  2) & 0x07),
1793                                       ((srcval >>  2) & 0xf8) | /* g */
1794                                       ((srcval >>  7) & 0x07),
1795                                       ((srcval >>  7) & 0xf8) | /* b */
1796                                       ((srcval >> 12) & 0x07) ) << (7-(x&7)) );
1797                             if ((x&7)==7) {
1798                                 *dstbyte++=dstval;
1799                                 dstval=0;
1800                             }
1801                         }
1802                         if ((dstwidth&7)!=0) {
1803                             *dstbyte=dstval;
1804                         }
1805                         srcbits = (char*)srcbits - bmpImage->bytes_per_line;
1806                         dstbits += linebytes;
1807                     }
1808                 } else {
1809                     goto notsupported;
1810                 }
1811             } else if (bmpImage->green_mask==0x07e0) {
1812                 if (bmpImage->red_mask==0xf800) {
1813                     /* ==== rgb 565 bmp -> pal 1 dib ==== */
1814                     for (h=0; h<lines; h++) {
1815                         BYTE dstval;
1816                         srcpixel=srcbits;
1817                         dstbyte=dstbits;
1818                         dstval=0;
1819                         for (x=0; x<dstwidth; x++) {
1820                             WORD srcval;
1821                             srcval=*srcpixel++;
1822                             dstval|=(X11DRV_DIB_GetNearestIndex
1823                                      (colors, 2,
1824                                       ((srcval >>  8) & 0xf8) | /* r */
1825                                       ((srcval >> 13) & 0x07),
1826                                       ((srcval >>  3) & 0xfc) | /* g */
1827                                       ((srcval >>  9) & 0x03),
1828                                       ((srcval <<  3) & 0xf8) | /* b */
1829                                       ((srcval >>  2) & 0x07) ) << (7-(x&7)) );
1830                             if ((x&7)==7) {
1831                                 *dstbyte++=dstval;
1832                                 dstval=0;
1833                             }
1834                         }
1835                         if ((dstwidth&7)!=0) {
1836                             *dstbyte=dstval;
1837                         }
1838                         srcbits = (char*)srcbits - bmpImage->bytes_per_line;
1839                         dstbits += linebytes;
1840                     }
1841                 } else if (bmpImage->blue_mask==0xf800) {
1842                     /* ==== bgr 565 bmp -> pal 1 dib ==== */
1843                     for (h=0; h<lines; h++) {
1844                         BYTE dstval;
1845                         srcpixel=srcbits;
1846                         dstbyte=dstbits;
1847                         dstval=0;
1848                         for (x=0; x<dstwidth; x++) {
1849                             WORD srcval;
1850                             srcval=*srcpixel++;
1851                             dstval|=(X11DRV_DIB_GetNearestIndex
1852                                      (colors, 2,
1853                                       ((srcval <<  3) & 0xf8) | /* r */
1854                                       ((srcval >>  2) & 0x07),
1855                                       ((srcval >>  3) & 0xfc) | /* g */
1856                                       ((srcval >>  9) & 0x03),
1857                                       ((srcval >>  8) & 0xf8) | /* b */
1858                                       ((srcval >> 13) & 0x07) ) << (7-(x&7)) );
1859                             if ((x&7)==7) {
1860                                 *dstbyte++=dstval;
1861                                 dstval=0;
1862                             }
1863                         }
1864                         if ((dstwidth&7)!=0) {
1865                             *dstbyte=dstval;
1866                         }
1867                         srcbits = (char*)srcbits - bmpImage->bytes_per_line;
1868                         dstbits += linebytes;
1869                     }
1870                 } else {
1871                     goto notsupported;
1872                 }
1873             } else {
1874                 goto notsupported;
1875             }
1876         }
1877         break;
1878
1879     case 24:
1880     case 32:
1881         {
1882             const void* srcbits;
1883             const BYTE *srcbyte;
1884             BYTE* dstbyte;
1885             int bytes_per_pixel;
1886
1887             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
1888             bytes_per_pixel=(bmpImage->bits_per_pixel==24?3:4);
1889
1890             if (bmpImage->green_mask!=0x00ff00 ||
1891                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
1892                 goto notsupported;
1893             } else if (bmpImage->blue_mask==0xff) {
1894                 /* ==== rgb 888 or 0888 bmp -> pal 1 dib ==== */
1895                 for (h=0; h<lines; h++) {
1896                     BYTE dstval;
1897                     srcbyte=srcbits;
1898                     dstbyte=dstbits;
1899                     dstval=0;
1900                     for (x=0; x<dstwidth; x++) {
1901                         dstval|=(X11DRV_DIB_GetNearestIndex
1902                                  (colors, 2,
1903                                   srcbyte[2],
1904                                   srcbyte[1],
1905                                   srcbyte[0]) << (7-(x&7)) );
1906                         srcbyte+=bytes_per_pixel;
1907                         if ((x&7)==7) {
1908                             *dstbyte++=dstval;
1909                             dstval=0;
1910                         }
1911                     }
1912                     if ((dstwidth&7)!=0) {
1913                         *dstbyte=dstval;
1914                     }
1915                     srcbits = (char*)srcbits - bmpImage->bytes_per_line;
1916                     dstbits += linebytes;
1917                 }
1918             } else {
1919                 /* ==== bgr 888 or 0888 bmp -> pal 1 dib ==== */
1920                 for (h=0; h<lines; h++) {
1921                     BYTE dstval;
1922                     srcbyte=srcbits;
1923                     dstbyte=dstbits;
1924                     dstval=0;
1925                     for (x=0; x<dstwidth; x++) {
1926                         dstval|=(X11DRV_DIB_GetNearestIndex
1927                                  (colors, 2,
1928                                   srcbyte[0],
1929                                   srcbyte[1],
1930                                   srcbyte[2]) << (7-(x&7)) );
1931                         srcbyte+=bytes_per_pixel;
1932                         if ((x&7)==7) {
1933                             *dstbyte++=dstval;
1934                             dstval=0;
1935                         }
1936                     }
1937                     if ((dstwidth&7)!=0) {
1938                         *dstbyte=dstval;
1939                     }
1940                     srcbits = (char*)srcbits - bmpImage->bytes_per_line;
1941                     dstbits += linebytes;
1942                 }
1943             }
1944         }
1945         break;
1946
1947     default:
1948     notsupported:
1949         {
1950             BYTE* dstbyte;
1951             unsigned long white = (1 << bmpImage->bits_per_pixel) - 1;
1952
1953             /* ==== any bmp format -> pal 1 dib ==== */
1954             WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 1 bit DIB\n",
1955                   bmpImage->bits_per_pixel, bmpImage->red_mask,
1956                   bmpImage->green_mask, bmpImage->blue_mask );
1957
1958             for (h=lines-1; h>=0; h--) {
1959                 BYTE dstval;
1960                 dstbyte=dstbits;
1961                 dstval=0;
1962                 for (x=0; x<dstwidth; x++) {
1963                     dstval|=(XGetPixel( bmpImage, x, h) >= white) << (7 - (x&7));
1964                     if ((x&7)==7) {
1965                         *dstbyte++=dstval;
1966                         dstval=0;
1967                     }
1968                 }
1969                 if ((dstwidth&7)!=0) {
1970                     *dstbyte=dstval;
1971                 }
1972                 dstbits += linebytes;
1973             }
1974         }
1975         break;
1976     }
1977 }
1978
1979 /***********************************************************************
1980  *           X11DRV_DIB_SetImageBits_4
1981  *
1982  * SetDIBits for a 4-bit deep DIB.
1983  */
1984 static void X11DRV_DIB_SetImageBits_4( int lines, const BYTE *srcbits,
1985                                 DWORD srcwidth, DWORD dstwidth, int left,
1986                                 int *colors, XImage *bmpImage, DWORD linebytes)
1987 {
1988     int h;
1989     const BYTE* srcbyte;
1990     DWORD i, x;
1991
1992     if (lines < 0 ) {
1993         lines = -lines;
1994         srcbits = srcbits + linebytes * (lines - 1);
1995         linebytes = -linebytes;
1996     }
1997
1998     if (left & 1) {
1999         left--;
2000         dstwidth++;
2001     }
2002     srcbits += left >> 1;
2003
2004     /* ==== pal 4 dib -> any bmp format ==== */
2005     for (h = lines-1; h >= 0; h--) {
2006         srcbyte=srcbits;
2007         for (i = dstwidth/2, x = left; i > 0; i--) {
2008             BYTE srcval=*srcbyte++;
2009             XPutPixel( bmpImage, x++, h, colors[srcval >> 4] );
2010             XPutPixel( bmpImage, x++, h, colors[srcval & 0x0f] );
2011         }
2012         if (dstwidth & 1)
2013             XPutPixel( bmpImage, x, h, colors[*srcbyte >> 4] );
2014         srcbits += linebytes;
2015     }
2016 }
2017
2018
2019
2020 /***********************************************************************
2021  *           X11DRV_DIB_GetImageBits_4
2022  *
2023  * GetDIBits for a 4-bit deep DIB.
2024  */
2025 static void X11DRV_DIB_GetImageBits_4( int lines, BYTE *dstbits,
2026                                        DWORD srcwidth, DWORD dstwidth,
2027                                        RGBQUAD *colors, PALETTEENTRY *srccolors,
2028                                        XImage *bmpImage, DWORD linebytes )
2029 {
2030     DWORD x;
2031     int h;
2032     BYTE *bits;
2033
2034     if (lines < 0 )
2035     {
2036        lines = -lines;
2037        dstbits = dstbits + ( linebytes * (lines-1) );
2038        linebytes = -linebytes;
2039     }
2040
2041     bits = dstbits;
2042
2043     switch (bmpImage->depth) {
2044     case 1:
2045     case 4:
2046         if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors) {
2047             /* ==== pal 1 or 4 bmp -> pal 4 dib ==== */
2048             BYTE* dstbyte;
2049
2050             for (h = lines-1; h >= 0; h--) {
2051                 BYTE dstval;
2052                 dstbyte=dstbits;
2053                 dstval=0;
2054                 for (x = 0; x < dstwidth; x++) {
2055                     PALETTEENTRY srcval;
2056                     srcval=srccolors[XGetPixel(bmpImage, x, h)];
2057                     dstval|=(X11DRV_DIB_GetNearestIndex
2058                              (colors, 16,
2059                               srcval.peRed,
2060                               srcval.peGreen,
2061                               srcval.peBlue) << (4-((x&1)<<2)));
2062                     if ((x&1)==1) {
2063                         *dstbyte++=dstval;
2064                         dstval=0;
2065                     }
2066                 }
2067                 if ((dstwidth&1)!=0) {
2068                     *dstbyte=dstval;
2069                 }
2070                 dstbits += linebytes;
2071             }
2072         } else {
2073             goto notsupported;
2074         }
2075         break;
2076
2077     case 8:
2078         if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors) {
2079             /* ==== pal 8 bmp -> pal 4 dib ==== */
2080             const void* srcbits;
2081             const BYTE *srcpixel;
2082             BYTE* dstbyte;
2083
2084             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2085             for (h=0; h<lines; h++) {
2086                 BYTE dstval;
2087                 srcpixel=srcbits;
2088                 dstbyte=dstbits;
2089                 dstval=0;
2090                 for (x=0; x<dstwidth; x++) {
2091                     PALETTEENTRY srcval;
2092                     srcval = srccolors[(int)*srcpixel++];
2093                     dstval|=(X11DRV_DIB_GetNearestIndex
2094                              (colors, 16,
2095                               srcval.peRed,
2096                               srcval.peGreen,
2097                               srcval.peBlue) << (4*(1-(x&1))) );
2098                     if ((x&1)==1) {
2099                         *dstbyte++=dstval;
2100                         dstval=0;
2101                     }
2102                 }
2103                 if ((dstwidth&1)!=0) {
2104                     *dstbyte=dstval;
2105                 }
2106                 srcbits = (char*)srcbits - bmpImage->bytes_per_line;
2107                 dstbits += linebytes;
2108             }
2109         } else {
2110             goto notsupported;
2111         }
2112         break;
2113
2114     case 15:
2115     case 16:
2116         {
2117             const void* srcbits;
2118             const WORD* srcpixel;
2119             BYTE* dstbyte;
2120
2121             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2122
2123             if (bmpImage->green_mask==0x03e0) {
2124                 if (bmpImage->red_mask==0x7c00) {
2125                     /* ==== rgb 555 bmp -> pal 4 dib ==== */
2126                     for (h=0; h<lines; h++) {
2127                         BYTE dstval;
2128                         srcpixel=srcbits;
2129                         dstbyte=dstbits;
2130                         dstval=0;
2131                         for (x=0; x<dstwidth; x++) {
2132                             WORD srcval;
2133                             srcval=*srcpixel++;
2134                             dstval|=(X11DRV_DIB_GetNearestIndex
2135                                      (colors, 16,
2136                                       ((srcval >>  7) & 0xf8) | /* r */
2137                                       ((srcval >> 12) & 0x07),
2138                                       ((srcval >>  2) & 0xf8) | /* g */
2139                                       ((srcval >>  7) & 0x07),
2140                                       ((srcval <<  3) & 0xf8) | /* b */
2141                                       ((srcval >>  2) & 0x07) ) << ((1-(x&1))<<2) );
2142                             if ((x&1)==1) {
2143                                 *dstbyte++=dstval;
2144                                 dstval=0;
2145                             }
2146                         }
2147                         if ((dstwidth&1)!=0) {
2148                             *dstbyte=dstval;
2149                         }
2150                         srcbits = (char*)srcbits - bmpImage->bytes_per_line;
2151                         dstbits += linebytes;
2152                     }
2153                 } else if (bmpImage->blue_mask==0x7c00) {
2154                     /* ==== bgr 555 bmp -> pal 4 dib ==== */
2155                     for (h=0; h<lines; h++) {
2156                         WORD dstval;
2157                         srcpixel=srcbits;
2158                         dstbyte=dstbits;
2159                         dstval=0;
2160                         for (x=0; x<dstwidth; x++) {
2161                             WORD srcval;
2162                             srcval=*srcpixel++;
2163                             dstval|=(X11DRV_DIB_GetNearestIndex
2164                                      (colors, 16,
2165                                       ((srcval <<  3) & 0xf8) | /* r */
2166                                       ((srcval >>  2) & 0x07),
2167                                       ((srcval >>  2) & 0xf8) | /* g */
2168                                       ((srcval >>  7) & 0x07),
2169                                       ((srcval >>  7) & 0xf8) | /* b */
2170                                       ((srcval >> 12) & 0x07) ) << ((1-(x&1))<<2) );
2171                             if ((x&1)==1) {
2172                                 *dstbyte++=dstval;
2173                                 dstval=0;
2174                             }
2175                         }
2176                         if ((dstwidth&1)!=0) {
2177                             *dstbyte=dstval;
2178                         }
2179                         srcbits = (char*)srcbits - bmpImage->bytes_per_line;
2180                         dstbits += linebytes;
2181                     }
2182                 } else {
2183                     goto notsupported;
2184                 }
2185             } else if (bmpImage->green_mask==0x07e0) {
2186                 if (bmpImage->red_mask==0xf800) {
2187                     /* ==== rgb 565 bmp -> pal 4 dib ==== */
2188                     for (h=0; h<lines; h++) {
2189                         BYTE dstval;
2190                         srcpixel=srcbits;
2191                         dstbyte=dstbits;
2192                         dstval=0;
2193                         for (x=0; x<dstwidth; x++) {
2194                             WORD srcval;
2195                             srcval=*srcpixel++;
2196                             dstval|=(X11DRV_DIB_GetNearestIndex
2197                                      (colors, 16,
2198                                       ((srcval >>  8) & 0xf8) | /* r */
2199                                       ((srcval >> 13) & 0x07),
2200                                       ((srcval >>  3) & 0xfc) | /* g */
2201                                       ((srcval >>  9) & 0x03),
2202                                       ((srcval <<  3) & 0xf8) | /* b */
2203                                       ((srcval >>  2) & 0x07) ) << ((1-(x&1))<<2) );
2204                             if ((x&1)==1) {
2205                                 *dstbyte++=dstval;
2206                                 dstval=0;
2207                             }
2208                         }
2209                         if ((dstwidth&1)!=0) {
2210                             *dstbyte=dstval;
2211                         }
2212                         srcbits = (char*)srcbits - bmpImage->bytes_per_line;
2213                         dstbits += linebytes;
2214                     }
2215                 } else if (bmpImage->blue_mask==0xf800) {
2216                     /* ==== bgr 565 bmp -> pal 4 dib ==== */
2217                     for (h=0; h<lines; h++) {
2218                         WORD dstval;
2219                         srcpixel=srcbits;
2220                         dstbyte=dstbits;
2221                         dstval=0;
2222                         for (x=0; x<dstwidth; x++) {
2223                             WORD srcval;
2224                             srcval=*srcpixel++;
2225                             dstval|=(X11DRV_DIB_GetNearestIndex
2226                                      (colors, 16,
2227                                       ((srcval <<  3) & 0xf8) | /* r */
2228                                       ((srcval >>  2) & 0x07),
2229                                       ((srcval >>  3) & 0xfc) | /* g */
2230                                       ((srcval >>  9) & 0x03),
2231                                       ((srcval >>  8) & 0xf8) | /* b */
2232                                       ((srcval >> 13) & 0x07) ) << ((1-(x&1))<<2) );
2233                             if ((x&1)==1) {
2234                                 *dstbyte++=dstval;
2235                                 dstval=0;
2236                             }
2237                         }
2238                         if ((dstwidth&1)!=0) {
2239                             *dstbyte=dstval;
2240                         }
2241                         srcbits = (char*)srcbits - bmpImage->bytes_per_line;
2242                         dstbits += linebytes;
2243                     }
2244                 } else {
2245                     goto notsupported;
2246                 }
2247             } else {
2248                 goto notsupported;
2249             }
2250         }
2251         break;
2252
2253     case 24:
2254         if (bmpImage->bits_per_pixel==24) {
2255             const void* srcbits;
2256             const BYTE *srcbyte;
2257             BYTE* dstbyte;
2258
2259             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2260
2261             if (bmpImage->green_mask!=0x00ff00 ||
2262                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2263                 goto notsupported;
2264             } else if (bmpImage->blue_mask==0xff) {
2265                 /* ==== rgb 888 bmp -> pal 4 dib ==== */
2266                 for (h=0; h<lines; h++) {
2267                     srcbyte=srcbits;
2268                     dstbyte=dstbits;
2269                     for (x=0; x<dstwidth/2; x++) {
2270                         /* Do 2 pixels at a time */
2271                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
2272                                     (colors, 16,
2273                                      srcbyte[2],
2274                                      srcbyte[1],
2275                                      srcbyte[0]) << 4) |
2276                                     X11DRV_DIB_GetNearestIndex
2277                                     (colors, 16,
2278                                      srcbyte[5],
2279                                      srcbyte[4],
2280                                      srcbyte[3]);
2281                         srcbyte+=6;
2282                     }
2283                     if (dstwidth&1) {
2284                         /* And the the odd pixel */
2285                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
2286                                     (colors, 16,
2287                                      srcbyte[2],
2288                                      srcbyte[1],
2289                                      srcbyte[0]) << 4);
2290                     }
2291                     srcbits = (char*)srcbits - bmpImage->bytes_per_line;
2292                     dstbits += linebytes;
2293                 }
2294             } else {
2295                 /* ==== bgr 888 bmp -> pal 4 dib ==== */
2296                 for (h=0; h<lines; h++) {
2297                     srcbyte=srcbits;
2298                     dstbyte=dstbits;
2299                     for (x=0; x<dstwidth/2; x++) {
2300                         /* Do 2 pixels at a time */
2301                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
2302                                     (colors, 16,
2303                                      srcbyte[0],
2304                                      srcbyte[1],
2305                                      srcbyte[2]) << 4) |
2306                                     X11DRV_DIB_GetNearestIndex
2307                                     (colors, 16,
2308                                      srcbyte[3],
2309                                      srcbyte[4],
2310                                      srcbyte[5]);
2311                         srcbyte+=6;
2312                     }
2313                     if (dstwidth&1) {
2314                         /* And the the odd pixel */
2315                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
2316                                     (colors, 16,
2317                                      srcbyte[0],
2318                                      srcbyte[1],
2319                                      srcbyte[2]) << 4);
2320                     }
2321                     srcbits = (char*)srcbits - bmpImage->bytes_per_line;
2322                     dstbits += linebytes;
2323                 }
2324             }
2325             break;
2326         }
2327         /* Fall through */
2328
2329     case 32:
2330         {
2331             const void* srcbits;
2332             const BYTE *srcbyte;
2333             BYTE* dstbyte;
2334
2335             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2336
2337             if (bmpImage->green_mask!=0x00ff00 ||
2338                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2339                 goto notsupported;
2340             } else if (bmpImage->blue_mask==0xff) {
2341                 /* ==== rgb 0888 bmp -> pal 4 dib ==== */
2342                 for (h=0; h<lines; h++) {
2343                     srcbyte=srcbits;
2344                     dstbyte=dstbits;
2345                     for (x=0; x<dstwidth/2; x++) {
2346                         /* Do 2 pixels at a time */
2347                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
2348                                     (colors, 16,
2349                                      srcbyte[2],
2350                                      srcbyte[1],
2351                                      srcbyte[0]) << 4) |
2352                                     X11DRV_DIB_GetNearestIndex
2353                                     (colors, 16,
2354                                      srcbyte[6],
2355                                      srcbyte[5],
2356                                      srcbyte[4]);
2357                         srcbyte+=8;
2358                     }
2359                     if (dstwidth&1) {
2360                         /* And the the odd pixel */
2361                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
2362                                     (colors, 16,
2363                                      srcbyte[2],
2364                                      srcbyte[1],
2365                                      srcbyte[0]) << 4);
2366                     }
2367                     srcbits = (char*)srcbits - bmpImage->bytes_per_line;
2368                     dstbits += linebytes;
2369                 }
2370             } else {
2371                 /* ==== bgr 0888 bmp -> pal 4 dib ==== */
2372                 for (h=0; h<lines; h++) {
2373                     srcbyte=srcbits;
2374                     dstbyte=dstbits;
2375                     for (x=0; x<dstwidth/2; x++) {
2376                         /* Do 2 pixels at a time */
2377                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
2378                                     (colors, 16,
2379                                      srcbyte[0],
2380                                      srcbyte[1],
2381                                      srcbyte[2]) << 4) |
2382                                     X11DRV_DIB_GetNearestIndex
2383                                     (colors, 16,
2384                                      srcbyte[4],
2385                                      srcbyte[5],
2386                                      srcbyte[6]);
2387                         srcbyte+=8;
2388                     }
2389                     if (dstwidth&1) {
2390                         /* And the the odd pixel */
2391                         *dstbyte++=(X11DRV_DIB_GetNearestIndex
2392                                     (colors, 16,
2393                                      srcbyte[0],
2394                                      srcbyte[1],
2395                                      srcbyte[2]) << 4);
2396                     }
2397                     srcbits = (char*)srcbits - bmpImage->bytes_per_line;
2398                     dstbits += linebytes;
2399                 }
2400             }
2401         }
2402         break;
2403
2404     default:
2405     notsupported:
2406         {
2407             BYTE* dstbyte;
2408
2409             /* ==== any bmp format -> pal 4 dib ==== */
2410             WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 4 bit DIB\n",
2411                   bmpImage->bits_per_pixel, bmpImage->red_mask,
2412                   bmpImage->green_mask, bmpImage->blue_mask );
2413             for (h=lines-1; h>=0; h--) {
2414                 dstbyte=dstbits;
2415                 for (x=0; x<(dstwidth & ~1); x+=2) {
2416                     *dstbyte++=(X11DRV_DIB_MapColor((int*)colors, 16, XGetPixel(bmpImage, x, h), 0) << 4) |
2417                         X11DRV_DIB_MapColor((int*)colors, 16, XGetPixel(bmpImage, x+1, h), 0);
2418                 }
2419                 if (dstwidth & 1) {
2420                     *dstbyte=(X11DRV_DIB_MapColor((int *)colors, 16, XGetPixel(bmpImage, x, h), 0) << 4);
2421                 }
2422                 dstbits += linebytes;
2423             }
2424         }
2425         break;
2426     }
2427 }
2428
2429 /***********************************************************************
2430  *           X11DRV_DIB_SetImageBits_RLE4
2431  *
2432  * SetDIBits for a 4-bit deep compressed DIB.
2433  */
2434 static void X11DRV_DIB_SetImageBits_RLE4( int lines, const BYTE *bits,
2435                                           DWORD width, DWORD dstwidth,
2436                                           int left, int *colors,
2437                                           XImage *bmpImage )
2438 {
2439     int x = 0, y = lines - 1, c, length;
2440     const BYTE *begin = bits;
2441
2442     while (y >= 0)
2443     {
2444         length = *bits++;
2445         if (length) {   /* encoded */
2446             c = *bits++;
2447             while (length--) {
2448                 if (x >= width) break;
2449                 XPutPixel(bmpImage, x++, y, colors[c >> 4]);
2450                 if (!length--) break;
2451                 if (x >= width) break;
2452                 XPutPixel(bmpImage, x++, y, colors[c & 0xf]);
2453             }
2454         } else {
2455             length = *bits++;
2456             switch (length)
2457             {
2458             case RLE_EOL:
2459                 x = 0;
2460                 y--;
2461                 break;
2462
2463             case RLE_END:
2464                 return;
2465
2466             case RLE_DELTA:
2467                 x += *bits++;
2468                 y -= *bits++;
2469                 break;
2470
2471             default: /* absolute */
2472                 while (length--) {
2473                     c = *bits++;
2474                     if (x < width) XPutPixel(bmpImage, x++, y, colors[c >> 4]);
2475                     if (!length--) break;
2476                     if (x < width) XPutPixel(bmpImage, x++, y, colors[c & 0xf]);
2477                 }
2478                 if ((bits - begin) & 1)
2479                     bits++;
2480             }
2481         }
2482     }
2483 }
2484
2485
2486
2487 /***********************************************************************
2488  *           X11DRV_DIB_SetImageBits_8
2489  *
2490  * SetDIBits for an 8-bit deep DIB.
2491  */
2492 static void X11DRV_DIB_SetImageBits_8( int lines, const BYTE *srcbits,
2493                                 DWORD srcwidth, DWORD dstwidth, int left,
2494                                 const int *colors, XImage *bmpImage,
2495                                 DWORD linebytes )
2496 {
2497     DWORD x;
2498     int h;
2499     const BYTE* srcbyte;
2500     BYTE* dstbits;
2501
2502     if (lines < 0 )
2503     {
2504         lines = -lines;
2505         srcbits = srcbits + linebytes * (lines-1);
2506         linebytes = -linebytes;
2507     }
2508     srcbits += left;
2509     srcbyte = srcbits;
2510
2511     switch (bmpImage->depth) {
2512     case 15:
2513     case 16:
2514 #if defined(__i386__) && defined(__GNUC__)
2515         /* Some X servers might have 32 bit/ 16bit deep pixel */
2516         if (lines && dstwidth && (bmpImage->bits_per_pixel == 16) &&
2517             (ImageByteOrder(gdi_display)==LSBFirst) )
2518         {
2519             dstbits=bmpImage->data+left*2+(lines-1)*bmpImage->bytes_per_line;
2520             /* FIXME: Does this really handle all these cases correctly? */
2521             /* ==== pal 8 dib -> rgb or bgr 555 or 565 bmp ==== */
2522             for (h = lines ; h--; ) {
2523                 int _cl1,_cl2; /* temp outputs for asm below */
2524                 /* Borrowed from DirectDraw */
2525                 __asm__ __volatile__(
2526                 "xor %%eax,%%eax\n"
2527                 "cld\n"
2528                 "1:\n"
2529                 "    lodsb\n"
2530                 "    movw (%%edx,%%eax,4),%%ax\n"
2531                 "    stosw\n"
2532                 "      xor %%eax,%%eax\n"
2533                 "    loop 1b\n"
2534                 :"=S" (srcbyte), "=D" (_cl1), "=c" (_cl2)
2535                 :"S" (srcbyte),
2536                  "D" (dstbits),
2537                  "c" (dstwidth),
2538                  "d" (colors)
2539                 :"eax", "cc", "memory"
2540                 );
2541                 srcbyte = (srcbits += linebytes);
2542                 dstbits -= bmpImage->bytes_per_line;
2543             }
2544             return;
2545         }
2546         break;
2547 #endif
2548     case 24:
2549     case 32:
2550 #if defined(__i386__) && defined(__GNUC__)
2551         if (lines && dstwidth && (bmpImage->bits_per_pixel == 32) &&
2552             (ImageByteOrder(gdi_display)==LSBFirst) )
2553         {
2554             dstbits=bmpImage->data+left*4+(lines-1)*bmpImage->bytes_per_line;
2555             /* FIXME: Does this really handle both cases correctly? */
2556             /* ==== pal 8 dib -> rgb or bgr 0888 bmp ==== */
2557             for (h = lines ; h--; ) {
2558                 int _cl1,_cl2; /* temp outputs for asm below */
2559                 /* Borrowed from DirectDraw */
2560                 __asm__ __volatile__(
2561                 "xor %%eax,%%eax\n"
2562                 "cld\n"
2563                 "1:\n"
2564                 "    lodsb\n"
2565                 "    movl (%%edx,%%eax,4),%%eax\n"
2566                 "    stosl\n"
2567                 "      xor %%eax,%%eax\n"
2568                 "    loop 1b\n"
2569                 :"=S" (srcbyte), "=D" (_cl1), "=c" (_cl2)
2570                 :"S" (srcbyte),
2571                  "D" (dstbits),
2572                  "c" (dstwidth),
2573                  "d" (colors)
2574                 :"eax", "cc", "memory"
2575                 );
2576                 srcbyte = (srcbits += linebytes);
2577                 dstbits -= bmpImage->bytes_per_line;
2578             }
2579             return;
2580         }
2581         break;
2582 #endif
2583     default:
2584         break; /* use slow generic case below */
2585     }
2586
2587     /* ==== pal 8 dib -> any bmp format ==== */
2588     for (h=lines-1; h>=0; h--) {
2589         for (x=left; x<dstwidth+left; x++) {
2590             XPutPixel(bmpImage, x, h, colors[*srcbyte++]);
2591         }
2592         srcbyte = (srcbits += linebytes);
2593     }
2594 }
2595
2596 /***********************************************************************
2597  *           X11DRV_DIB_GetImageBits_8
2598  *
2599  * GetDIBits for an 8-bit deep DIB.
2600  */
2601 static void X11DRV_DIB_GetImageBits_8( int lines, BYTE *dstbits,
2602                                        DWORD srcwidth, DWORD dstwidth,
2603                                        RGBQUAD *colors, PALETTEENTRY *srccolors,
2604                                        XImage *bmpImage, DWORD linebytes )
2605 {
2606     DWORD x;
2607     int h;
2608     BYTE* dstbyte;
2609
2610     if (lines < 0 )
2611     {
2612        lines = -lines;
2613        dstbits = dstbits + ( linebytes * (lines-1) );
2614        linebytes = -linebytes;
2615     }
2616
2617     /*
2618      * Hack for now
2619      * This condition is true when GetImageBits has been called by
2620      * UpdateDIBSection. For now, GetNearestIndex is too slow to support
2621      * 256 colormaps, so we'll just use for for GetDIBits calls.
2622      * (In somes cases, in a updateDIBSection, the returned colors are bad too)
2623      */
2624     if (!srccolors) goto updatesection;
2625
2626     switch (bmpImage->depth) {
2627     case 1:
2628     case 4:
2629         if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors) {
2630
2631             /* ==== pal 1 bmp -> pal 8 dib ==== */
2632             /* ==== pal 4 bmp -> pal 8 dib ==== */
2633             for (h=lines-1; h>=0; h--) {
2634                 dstbyte=dstbits;
2635                 for (x=0; x<dstwidth; x++) {
2636                     PALETTEENTRY srcval;
2637                     srcval=srccolors[XGetPixel(bmpImage, x, h)];
2638                     *dstbyte++=X11DRV_DIB_GetNearestIndex(colors, 256,
2639                                                           srcval.peRed,
2640                                                           srcval.peGreen,
2641                                                           srcval.peBlue);
2642                 }
2643                 dstbits += linebytes;
2644             }
2645         } else {
2646             goto notsupported;
2647         }
2648         break;
2649
2650     case 8:
2651        if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors) {
2652             /* ==== pal 8 bmp -> pal 8 dib ==== */
2653            const void* srcbits;
2654            const BYTE* srcpixel;
2655
2656            srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2657            for (h=0; h<lines; h++) {
2658                srcpixel=srcbits;
2659                dstbyte=dstbits;
2660                for (x = 0; x < dstwidth; x++) {
2661                    PALETTEENTRY srcval;
2662                    srcval=srccolors[(int)*srcpixel++];
2663                    *dstbyte++=X11DRV_DIB_GetNearestIndex(colors, 256,
2664                                                          srcval.peRed,
2665                                                          srcval.peGreen,
2666                                                          srcval.peBlue);
2667                }
2668                srcbits = (char*)srcbits - bmpImage->bytes_per_line;
2669                dstbits += linebytes;
2670            }
2671        } else {
2672            goto notsupported;
2673        }
2674        break;
2675
2676     case 15:
2677     case 16:
2678         {
2679             const void* srcbits;
2680             const WORD* srcpixel;
2681             BYTE* dstbyte;
2682
2683             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2684
2685             if (bmpImage->green_mask==0x03e0) {
2686                 if (bmpImage->red_mask==0x7c00) {
2687                     /* ==== rgb 555 bmp -> pal 8 dib ==== */
2688                     for (h=0; h<lines; h++) {
2689                         srcpixel=srcbits;
2690                         dstbyte=dstbits;
2691                         for (x=0; x<dstwidth; x++) {
2692                             WORD srcval;
2693                             srcval=*srcpixel++;
2694                             *dstbyte++=X11DRV_DIB_GetNearestIndex
2695                                 (colors, 256,
2696                                  ((srcval >>  7) & 0xf8) | /* r */
2697                                  ((srcval >> 12) & 0x07),
2698                                  ((srcval >>  2) & 0xf8) | /* g */
2699                                  ((srcval >>  7) & 0x07),
2700                                  ((srcval <<  3) & 0xf8) | /* b */
2701                                  ((srcval >>  2) & 0x07) );
2702                         }
2703                         srcbits = (char*)srcbits - bmpImage->bytes_per_line;
2704                         dstbits += linebytes;
2705                     }
2706                 } else if (bmpImage->blue_mask==0x7c00) {
2707                     /* ==== bgr 555 bmp -> pal 8 dib ==== */
2708                     for (h=0; h<lines; h++) {
2709                         srcpixel=srcbits;
2710                         dstbyte=dstbits;
2711                         for (x=0; x<dstwidth; x++) {
2712                             WORD srcval;
2713                             srcval=*srcpixel++;
2714                             *dstbyte++=X11DRV_DIB_GetNearestIndex
2715                                 (colors, 256,
2716                                  ((srcval <<  3) & 0xf8) | /* r */
2717                                  ((srcval >>  2) & 0x07),
2718                                  ((srcval >>  2) & 0xf8) | /* g */
2719                                  ((srcval >>  7) & 0x07),
2720                                  ((srcval >>  7) & 0xf8) | /* b */
2721                                  ((srcval >> 12) & 0x07) );
2722                         }
2723                         srcbits = (char*)srcbits - bmpImage->bytes_per_line;
2724                         dstbits += linebytes;
2725                     }
2726                 } else {
2727                     goto notsupported;
2728                 }
2729             } else if (bmpImage->green_mask==0x07e0) {
2730                 if (bmpImage->red_mask==0xf800) {
2731                     /* ==== rgb 565 bmp -> pal 8 dib ==== */
2732                     for (h=0; h<lines; h++) {
2733                         srcpixel=srcbits;
2734                         dstbyte=dstbits;
2735                         for (x=0; x<dstwidth; x++) {
2736                             WORD srcval;
2737                             srcval=*srcpixel++;
2738                             *dstbyte++=X11DRV_DIB_GetNearestIndex
2739                                 (colors, 256,
2740                                  ((srcval >>  8) & 0xf8) | /* r */
2741                                  ((srcval >> 13) & 0x07),
2742                                  ((srcval >>  3) & 0xfc) | /* g */
2743                                  ((srcval >>  9) & 0x03),
2744                                  ((srcval <<  3) & 0xf8) | /* b */
2745                                  ((srcval >>  2) & 0x07) );
2746                         }
2747                         srcbits = (char*)srcbits - bmpImage->bytes_per_line;
2748                         dstbits += linebytes;
2749                     }
2750                 } else if (bmpImage->blue_mask==0xf800) {
2751                     /* ==== bgr 565 bmp -> pal 8 dib ==== */
2752                     for (h=0; h<lines; h++) {
2753                         srcpixel=srcbits;
2754                         dstbyte=dstbits;
2755                         for (x=0; x<dstwidth; x++) {
2756                             WORD srcval;
2757                             srcval=*srcpixel++;
2758                             *dstbyte++=X11DRV_DIB_GetNearestIndex
2759                                 (colors, 256,
2760                                  ((srcval <<  3) & 0xf8) | /* r */
2761                                  ((srcval >>  2) & 0x07),
2762                                  ((srcval >>  3) & 0xfc) | /* g */
2763                                  ((srcval >>  9) & 0x03),
2764                                  ((srcval >>  8) & 0xf8) | /* b */
2765                                  ((srcval >> 13) & 0x07) );
2766                         }
2767                         srcbits = (char*)srcbits - bmpImage->bytes_per_line;
2768                         dstbits += linebytes;
2769                     }
2770                 } else {
2771                     goto notsupported;
2772                 }
2773             } else {
2774                 goto notsupported;
2775             }
2776         }
2777         break;
2778
2779     case 24:
2780     case 32:
2781         {
2782             const void* srcbits;
2783             const BYTE *srcbyte;
2784             BYTE* dstbyte;
2785             int bytes_per_pixel;
2786
2787             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
2788             bytes_per_pixel=(bmpImage->bits_per_pixel==24?3:4);
2789
2790             if (bmpImage->green_mask!=0x00ff00 ||
2791                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
2792                 goto notsupported;
2793             } else if (bmpImage->blue_mask==0xff) {
2794                 /* ==== rgb 888 or 0888 bmp -> pal 8 dib ==== */
2795                 for (h=0; h<lines; h++) {
2796                     srcbyte=srcbits;
2797                     dstbyte=dstbits;
2798                     for (x=0; x<dstwidth; x++) {
2799                         *dstbyte++=X11DRV_DIB_GetNearestIndex
2800                             (colors, 256,
2801                              srcbyte[2],
2802                              srcbyte[1],
2803                              srcbyte[0]);
2804                         srcbyte+=bytes_per_pixel;
2805                     }
2806                     srcbits = (char*)srcbits - bmpImage->bytes_per_line;
2807                     dstbits += linebytes;
2808                 }
2809             } else {
2810                 /* ==== bgr 888 or 0888 bmp -> pal 8 dib ==== */
2811                 for (h=0; h<lines; h++) {
2812                     srcbyte=srcbits;
2813                     dstbyte=dstbits;
2814                     for (x=0; x<dstwidth; x++) {
2815                         *dstbyte++=X11DRV_DIB_GetNearestIndex
2816                             (colors, 256,
2817                              srcbyte[0],
2818                              srcbyte[1],
2819                              srcbyte[2]);
2820                         srcbyte+=bytes_per_pixel;
2821                     }
2822                     srcbits = (char*)srcbits - bmpImage->bytes_per_line;
2823                     dstbits += linebytes;
2824                 }
2825             }
2826         }
2827         break;
2828
2829     default:
2830     notsupported:
2831         WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 8 bit DIB\n",
2832               bmpImage->depth, bmpImage->red_mask,
2833               bmpImage->green_mask, bmpImage->blue_mask );
2834     updatesection:
2835         /* ==== any bmp format -> pal 8 dib ==== */
2836         for (h=lines-1; h>=0; h--) {
2837             dstbyte=dstbits;
2838             for (x=0; x<dstwidth; x++) {
2839                 *dstbyte=X11DRV_DIB_MapColor
2840                     ((int*)colors, 256,
2841                      XGetPixel(bmpImage, x, h), *dstbyte);
2842                 dstbyte++;
2843             }
2844             dstbits += linebytes;
2845         }
2846         break;
2847     }
2848 }
2849
2850 /***********************************************************************
2851  *            X11DRV_DIB_SetImageBits_RLE8
2852  *
2853  * SetDIBits for an 8-bit deep compressed DIB.
2854  *
2855  * This function rewritten 941113 by James Youngman.  WINE blew out when I
2856  * first ran it because my desktop wallpaper is a (large) RLE8 bitmap.
2857  *
2858  * This was because the algorithm assumed that all RLE8 bitmaps end with the
2859  * 'End of bitmap' escape code.  This code is very much laxer in what it
2860  * allows to end the expansion.  Possibly too lax.  See the note by
2861  * case RleDelta.  BTW, MS's documentation implies that a correct RLE8
2862  * bitmap should end with RleEnd, but on the other hand, software exists
2863  * that produces ones that don't and Windows 3.1 doesn't complain a bit
2864  * about it.
2865  *
2866  * (No) apologies for my English spelling.  [Emacs users: c-indent-level=4].
2867  *                      James A. Youngman <mbcstjy@afs.man.ac.uk>
2868  *                                              [JAY]
2869  */
2870 static void X11DRV_DIB_SetImageBits_RLE8( int lines, const BYTE *bits,
2871                                           DWORD width, DWORD dstwidth,
2872                                           int left, int *colors,
2873                                           XImage *bmpImage )
2874 {
2875     int x;                      /* X-positon on each line.  Increases. */
2876     int y;                      /* Line #.  Starts at lines-1, decreases */
2877     const BYTE *pIn = bits;     /* Pointer to current position in bits */
2878     BYTE length;                /* The length pf a run */
2879     BYTE escape_code;           /* See enum Rle8_EscapeCodes.*/
2880
2881     /*
2882      * Note that the bitmap data is stored by Windows starting at the
2883      * bottom line of the bitmap and going upwards.  Within each line,
2884      * the data is stored left-to-right.  That's the reason why line
2885      * goes from lines-1 to 0.                  [JAY]
2886      */
2887
2888     x = 0;
2889     y = lines - 1;
2890     while (y >= 0)
2891     {
2892         length = *pIn++;
2893
2894         /*
2895          * If the length byte is not zero (which is the escape value),
2896          * We have a run of length pixels all the same colour.  The colour
2897          * index is stored next.
2898          *
2899          * If the length byte is zero, we need to read the next byte to
2900          * know what to do.                     [JAY]
2901          */
2902         if (length != 0)
2903         {
2904             /*
2905              * [Run-Length] Encoded mode
2906              */
2907             int color = colors[*pIn++];
2908             while (length-- && x < dstwidth) XPutPixel(bmpImage, x++, y, color);
2909         }
2910         else
2911         {
2912             /*
2913              * Escape codes (may be an absolute sequence though)
2914              */
2915             escape_code = (*pIn++);
2916             switch(escape_code)
2917             {
2918             case RLE_EOL:
2919                 x = 0;
2920                 y--;
2921                 break;
2922
2923             case RLE_END:
2924                 /* Not all RLE8 bitmaps end with this code.  For
2925                  * example, Paint Shop Pro produces some that don't.
2926                  * That's (I think) what caused the previous
2927                  * implementation to fail.  [JAY]
2928                  */
2929                 return;
2930
2931             case RLE_DELTA:
2932                 x += (*pIn++);
2933                 y -= (*pIn++);
2934                 break;
2935
2936             default:  /* switch to absolute mode */
2937                 length = escape_code;
2938                 while (length--)
2939                 {
2940                     int color = colors[*pIn++];
2941                     if (x >= dstwidth)
2942                     {
2943                         pIn += length;
2944                         break;
2945                     }
2946                     XPutPixel(bmpImage, x++, y, color);
2947                 }
2948                 /*
2949                  * If you think for a moment you'll realise that the
2950                  * only time we could ever possibly read an odd
2951                  * number of bytes is when there is a 0x00 (escape),
2952                  * a value >0x02 (absolute mode) and then an odd-
2953                  * length run.  Therefore this is the only place we
2954                  * need to worry about it.  Everywhere else the
2955                  * bytes are always read in pairs.  [JAY]
2956                  */
2957                 if (escape_code & 1) pIn++; /* Throw away the pad byte. */
2958                 break;
2959             } /* switch (escape_code) : Escape sequence */
2960         }
2961     }
2962 }
2963
2964
2965 /***********************************************************************
2966  *           X11DRV_DIB_SetImageBits_16
2967  *
2968  * SetDIBits for a 16-bit deep DIB.
2969  */
2970 static void X11DRV_DIB_SetImageBits_16( int lines, const BYTE *srcbits,
2971                                  DWORD srcwidth, DWORD dstwidth, int left,
2972                                        X11DRV_PDEVICE *physDev, DWORD rSrc, DWORD gSrc, DWORD bSrc,
2973                                        XImage *bmpImage, DWORD linebytes )
2974 {
2975     DWORD x;
2976     int h;
2977
2978     if (lines < 0 )
2979     {
2980         lines = -lines;
2981         srcbits = srcbits + ( linebytes * (lines-1));
2982         linebytes = -linebytes;
2983     }
2984
2985     switch (bmpImage->depth)
2986     {
2987     case 15:
2988     case 16:
2989         {
2990             char* dstbits;
2991
2992             srcbits=srcbits+left*2;
2993             dstbits=bmpImage->data+left*2+(lines-1)*bmpImage->bytes_per_line;
2994
2995             if (bmpImage->green_mask==0x03e0) {
2996                 if (gSrc==bmpImage->green_mask) {
2997                     if (rSrc==bmpImage->red_mask) {
2998                         /* ==== rgb 555 dib -> rgb 555 bmp ==== */
2999                         /* ==== bgr 555 dib -> bgr 555 bmp ==== */
3000                         X11DRV_DIB_Convert_any_asis
3001                             (dstwidth,lines,2,
3002                              srcbits,linebytes,
3003                              dstbits,-bmpImage->bytes_per_line);
3004                     } else if (rSrc==bmpImage->blue_mask) {
3005                         /* ==== rgb 555 dib -> bgr 555 bmp ==== */
3006                         /* ==== bgr 555 dib -> rgb 555 bmp ==== */
3007                         X11DRV_DIB_Convert_555_reverse
3008                             (dstwidth,lines,
3009                              srcbits,linebytes,
3010                              dstbits,-bmpImage->bytes_per_line);
3011                     }
3012                 } else {
3013                     if (rSrc==bmpImage->red_mask || bSrc==bmpImage->blue_mask) {
3014                         /* ==== rgb 565 dib -> rgb 555 bmp ==== */
3015                         /* ==== bgr 565 dib -> bgr 555 bmp ==== */
3016                         X11DRV_DIB_Convert_565_to_555_asis
3017                             (dstwidth,lines,
3018                              srcbits,linebytes,
3019                              dstbits,-bmpImage->bytes_per_line);
3020                     } else {
3021                         /* ==== rgb 565 dib -> bgr 555 bmp ==== */
3022                         /* ==== bgr 565 dib -> rgb 555 bmp ==== */
3023                         X11DRV_DIB_Convert_565_to_555_reverse
3024                             (dstwidth,lines,
3025                              srcbits,linebytes,
3026                              dstbits,-bmpImage->bytes_per_line);
3027                     }
3028                 }
3029             } else if (bmpImage->green_mask==0x07e0) {
3030                 if (gSrc==bmpImage->green_mask) {
3031                     if (rSrc==bmpImage->red_mask) {
3032                         /* ==== rgb 565 dib -> rgb 565 bmp ==== */
3033                         /* ==== bgr 565 dib -> bgr 565 bmp ==== */
3034                         X11DRV_DIB_Convert_any_asis
3035                             (dstwidth,lines,2,
3036                              srcbits,linebytes,
3037                              dstbits,-bmpImage->bytes_per_line);
3038                     } else {
3039                         /* ==== rgb 565 dib -> bgr 565 bmp ==== */
3040                         /* ==== bgr 565 dib -> rgb 565 bmp ==== */
3041                         X11DRV_DIB_Convert_565_reverse
3042                             (dstwidth,lines,
3043                              srcbits,linebytes,
3044                              dstbits,-bmpImage->bytes_per_line);
3045                     }
3046                 } else {
3047                     if (rSrc==bmpImage->red_mask || bSrc==bmpImage->blue_mask) {
3048                         /* ==== rgb 555 dib -> rgb 565 bmp ==== */
3049                         /* ==== bgr 555 dib -> bgr 565 bmp ==== */
3050                         X11DRV_DIB_Convert_555_to_565_asis
3051                             (dstwidth,lines,
3052                              srcbits,linebytes,
3053                              dstbits,-bmpImage->bytes_per_line);
3054                     } else {
3055                         /* ==== rgb 555 dib -> bgr 565 bmp ==== */
3056                         /* ==== bgr 555 dib -> rgb 565 bmp ==== */
3057                         X11DRV_DIB_Convert_555_to_565_reverse
3058                             (dstwidth,lines,
3059                              srcbits,linebytes,
3060                              dstbits,-bmpImage->bytes_per_line);
3061                     }
3062                 }
3063             } else {
3064                 goto notsupported;
3065             }
3066         }
3067         break;
3068
3069     case 24:
3070         if (bmpImage->bits_per_pixel==24) {
3071             char* dstbits;
3072
3073             srcbits=srcbits+left*2;
3074             dstbits=bmpImage->data+left*3+(lines-1)*bmpImage->bytes_per_line;
3075
3076             if (bmpImage->green_mask!=0x00ff00 ||
3077                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
3078                 goto notsupported;
3079             } else if ((rSrc==0x1f && bmpImage->red_mask==0xff) ||
3080                        (bSrc==0x1f && bmpImage->blue_mask==0xff)) {
3081                 if (gSrc==0x03e0) {
3082                     /* ==== rgb 555 dib -> rgb 888 bmp ==== */
3083                     /* ==== bgr 555 dib -> bgr 888 bmp ==== */
3084                     X11DRV_DIB_Convert_555_to_888_asis
3085                         (dstwidth,lines,
3086                          srcbits,linebytes,
3087                          dstbits,-bmpImage->bytes_per_line);
3088                 } else {
3089                     /* ==== rgb 565 dib -> rgb 888 bmp ==== */
3090                     /* ==== bgr 565 dib -> bgr 888 bmp ==== */
3091                     X11DRV_DIB_Convert_565_to_888_asis
3092                         (dstwidth,lines,
3093                          srcbits,linebytes,
3094                          dstbits,-bmpImage->bytes_per_line);
3095                 }
3096             } else {
3097                 if (gSrc==0x03e0) {
3098                     /* ==== rgb 555 dib -> bgr 888 bmp ==== */
3099                     /* ==== bgr 555 dib -> rgb 888 bmp ==== */
3100                     X11DRV_DIB_Convert_555_to_888_reverse
3101                         (dstwidth,lines,
3102                          srcbits,linebytes,
3103                          dstbits,-bmpImage->bytes_per_line);
3104                 } else {
3105                     /* ==== rgb 565 dib -> bgr 888 bmp ==== */
3106                     /* ==== bgr 565 dib -> rgb 888 bmp ==== */
3107                     X11DRV_DIB_Convert_565_to_888_reverse
3108                         (dstwidth,lines,
3109                          srcbits,linebytes,
3110                          dstbits,-bmpImage->bytes_per_line);
3111                 }
3112             }
3113             break;
3114         }
3115         /* Fall through */
3116
3117     case 32:
3118         {
3119             char* dstbits;
3120
3121             srcbits=srcbits+left*2;
3122             dstbits=bmpImage->data+left*4+(lines-1)*bmpImage->bytes_per_line;
3123
3124             if (bmpImage->green_mask!=0x00ff00 ||
3125                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
3126                 goto notsupported;
3127             } else if ((rSrc==0x1f && bmpImage->red_mask==0xff) ||
3128                        (bSrc==0x1f && bmpImage->blue_mask==0xff)) {
3129                 if (gSrc==0x03e0) {
3130                     /* ==== rgb 555 dib -> rgb 0888 bmp ==== */
3131                     /* ==== bgr 555 dib -> bgr 0888 bmp ==== */
3132                     X11DRV_DIB_Convert_555_to_0888_asis
3133                         (dstwidth,lines,
3134                          srcbits,linebytes,
3135                          dstbits,-bmpImage->bytes_per_line);
3136                 } else {
3137                     /* ==== rgb 565 dib -> rgb 0888 bmp ==== */
3138                     /* ==== bgr 565 dib -> bgr 0888 bmp ==== */
3139                     X11DRV_DIB_Convert_565_to_0888_asis
3140                         (dstwidth,lines,
3141                          srcbits,linebytes,
3142                          dstbits,-bmpImage->bytes_per_line);
3143                 }
3144             } else {
3145                 if (gSrc==0x03e0) {
3146                     /* ==== rgb 555 dib -> bgr 0888 bmp ==== */
3147                     /* ==== bgr 555 dib -> rgb 0888 bmp ==== */
3148                     X11DRV_DIB_Convert_555_to_0888_reverse
3149                         (dstwidth,lines,
3150                          srcbits,linebytes,
3151                          dstbits,-bmpImage->bytes_per_line);
3152                 } else {
3153                     /* ==== rgb 565 dib -> bgr 0888 bmp ==== */
3154                     /* ==== bgr 565 dib -> rgb 0888 bmp ==== */
3155                     X11DRV_DIB_Convert_565_to_0888_reverse
3156                         (dstwidth,lines,
3157                          srcbits,linebytes,
3158                          dstbits,-bmpImage->bytes_per_line);
3159                 }
3160             }
3161         }
3162         break;
3163
3164     default:
3165     notsupported:
3166         WARN("from 16 bit DIB (%lx,%lx,%lx) to unknown %d bit bitmap (%lx,%lx,%lx)\n",
3167               rSrc, gSrc, bSrc, bmpImage->bits_per_pixel, bmpImage->red_mask,
3168               bmpImage->green_mask, bmpImage->blue_mask );
3169         /* fall through */
3170     case 1:
3171     case 4:
3172     case 8:
3173         {
3174             /* ==== rgb or bgr 555 or 565 dib -> pal 1, 4 or 8 ==== */
3175             const WORD* srcpixel;
3176             int rShift1,gShift1,bShift1;
3177             int rShift2,gShift2,bShift2;
3178             BYTE gMask1,gMask2;
3179
3180             /* Set color scaling values */
3181             rShift1=16+X11DRV_DIB_MaskToShift(rSrc)-3;
3182             gShift1=16+X11DRV_DIB_MaskToShift(gSrc)-3;
3183             bShift1=16+X11DRV_DIB_MaskToShift(bSrc)-3;
3184             rShift2=rShift1+5;
3185             gShift2=gShift1+5;
3186             bShift2=bShift1+5;
3187             if (gSrc==0x03e0) {
3188                 /* Green has 5 bits, like the others */
3189                 gMask1=0xf8;
3190                 gMask2=0x07;
3191             } else {
3192                 /* Green has 6 bits, not 5. Compensate. */
3193                 gShift1++;
3194                 gShift2+=2;
3195                 gMask1=0xfc;
3196                 gMask2=0x03;
3197             }
3198
3199             srcbits+=2*left;
3200
3201             /* We could split it into four separate cases to optimize
3202              * but it is probably not worth it.
3203              */
3204             for (h=lines-1; h>=0; h--) {
3205                 srcpixel=(const WORD*)srcbits;
3206                 for (x=left; x<dstwidth+left; x++) {
3207                     DWORD srcval;
3208                     BYTE red,green,blue;
3209                     srcval=*srcpixel++ << 16;
3210                     red=  ((srcval >> rShift1) & 0xf8) |
3211                         ((srcval >> rShift2) & 0x07);
3212                     green=((srcval >> gShift1) & gMask1) |
3213                         ((srcval >> gShift2) & gMask2);
3214                     blue= ((srcval >> bShift1) & 0xf8) |
3215                         ((srcval >> bShift2) & 0x07);
3216                     XPutPixel(bmpImage, x, h,
3217                               X11DRV_PALETTE_ToPhysical
3218                               (physDev, RGB(red,green,blue)));
3219                 }
3220                 srcbits += linebytes;
3221             }
3222         }
3223         break;
3224     }
3225 }
3226
3227
3228 /***********************************************************************
3229  *           X11DRV_DIB_GetImageBits_16
3230  *
3231  * GetDIBits for an 16-bit deep DIB.
3232  */
3233 static void X11DRV_DIB_GetImageBits_16( int lines, BYTE *dstbits,
3234                                         DWORD dstwidth, DWORD srcwidth,
3235                                         PALETTEENTRY *srccolors,
3236                                         DWORD rDst, DWORD gDst, DWORD bDst,
3237                                         XImage *bmpImage, DWORD dibpitch )
3238 {
3239     DWORD x;
3240     int h;
3241
3242     DWORD linebytes = dibpitch;
3243
3244     if (lines < 0 )
3245     {
3246         lines = -lines;
3247         dstbits = dstbits + ( linebytes * (lines-1));
3248         linebytes = -linebytes;
3249     }
3250
3251     switch (bmpImage->depth)
3252     {
3253     case 15:
3254     case 16:
3255         {
3256             const char* srcbits;
3257
3258             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3259
3260             if (bmpImage->green_mask==0x03e0) {
3261                 if (gDst==bmpImage->green_mask) {
3262                     if (rDst==bmpImage->red_mask) {
3263                         /* ==== rgb 555 bmp -> rgb 555 dib ==== */
3264                         /* ==== bgr 555 bmp -> bgr 555 dib ==== */
3265                         X11DRV_DIB_Convert_any_asis
3266                             (dstwidth,lines,2,
3267                              srcbits,-bmpImage->bytes_per_line,
3268                              dstbits,linebytes);
3269                     } else {
3270                         /* ==== rgb 555 bmp -> bgr 555 dib ==== */
3271                         /* ==== bgr 555 bmp -> rgb 555 dib ==== */
3272                         X11DRV_DIB_Convert_555_reverse
3273                             (dstwidth,lines,
3274                              srcbits,-bmpImage->bytes_per_line,
3275                              dstbits,linebytes);
3276                     }
3277                 } else {
3278                     if (rDst==bmpImage->red_mask || bDst==bmpImage->blue_mask) {
3279                         /* ==== rgb 555 bmp -> rgb 565 dib ==== */
3280                         /* ==== bgr 555 bmp -> bgr 565 dib ==== */
3281                         X11DRV_DIB_Convert_555_to_565_asis
3282                             (dstwidth,lines,
3283                              srcbits,-bmpImage->bytes_per_line,
3284                              dstbits,linebytes);
3285                     } else {
3286                         /* ==== rgb 555 bmp -> bgr 565 dib ==== */
3287                         /* ==== bgr 555 bmp -> rgb 565 dib ==== */
3288                         X11DRV_DIB_Convert_555_to_565_reverse
3289                             (dstwidth,lines,
3290                              srcbits,-bmpImage->bytes_per_line,
3291                              dstbits,linebytes);
3292                     }
3293                 }
3294             } else if (bmpImage->green_mask==0x07e0) {
3295                 if (gDst==bmpImage->green_mask) {
3296                     if (rDst == bmpImage->red_mask) {
3297                         /* ==== rgb 565 bmp -> rgb 565 dib ==== */
3298                         /* ==== bgr 565 bmp -> bgr 565 dib ==== */
3299                         X11DRV_DIB_Convert_any_asis
3300                             (dstwidth,lines,2,
3301                              srcbits,-bmpImage->bytes_per_line,
3302                              dstbits,linebytes);
3303                     } else {
3304                         /* ==== rgb 565 bmp -> bgr 565 dib ==== */
3305                         /* ==== bgr 565 bmp -> rgb 565 dib ==== */
3306                         X11DRV_DIB_Convert_565_reverse
3307                             (dstwidth,lines,
3308                              srcbits,-bmpImage->bytes_per_line,
3309                              dstbits,linebytes);
3310                     }
3311                 } else {
3312                     if (rDst==bmpImage->red_mask || bDst==bmpImage->blue_mask) {
3313                         /* ==== rgb 565 bmp -> rgb 555 dib ==== */
3314                         /* ==== bgr 565 bmp -> bgr 555 dib ==== */
3315                         X11DRV_DIB_Convert_565_to_555_asis
3316                             (dstwidth,lines,
3317                              srcbits,-bmpImage->bytes_per_line,
3318                              dstbits,linebytes);
3319                     } else {
3320                         /* ==== rgb 565 bmp -> bgr 555 dib ==== */
3321                         /* ==== bgr 565 bmp -> rgb 555 dib ==== */
3322                         X11DRV_DIB_Convert_565_to_555_reverse
3323                             (dstwidth,lines,
3324                              srcbits,-bmpImage->bytes_per_line,
3325                              dstbits,linebytes);
3326                     }
3327                 }
3328             } else {
3329                 goto notsupported;
3330             }
3331         }
3332         break;
3333
3334     case 24:
3335         if (bmpImage->bits_per_pixel == 24) {
3336             const char* srcbits;
3337
3338             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3339
3340             if (bmpImage->green_mask!=0x00ff00 ||
3341                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
3342                 goto notsupported;
3343             } else if ((rDst==0x1f && bmpImage->red_mask==0xff) ||
3344                     (bDst==0x1f && bmpImage->blue_mask==0xff)) {
3345                 if (gDst==0x03e0) {
3346                     /* ==== rgb 888 bmp -> rgb 555 dib ==== */
3347                     /* ==== bgr 888 bmp -> bgr 555 dib ==== */
3348                     X11DRV_DIB_Convert_888_to_555_asis
3349                         (dstwidth,lines,
3350                          srcbits,-bmpImage->bytes_per_line,
3351                          dstbits,linebytes);
3352                 } else {
3353                     /* ==== rgb 888 bmp -> rgb 565 dib ==== */
3354                     /* ==== rgb 888 bmp -> rgb 565 dib ==== */
3355                     X11DRV_DIB_Convert_888_to_565_asis
3356                         (dstwidth,lines,
3357                          srcbits,-bmpImage->bytes_per_line,
3358                          dstbits,linebytes);
3359                 }
3360             } else {
3361                 if (gDst==0x03e0) {
3362                     /* ==== rgb 888 bmp -> bgr 555 dib ==== */
3363                     /* ==== bgr 888 bmp -> rgb 555 dib ==== */
3364                     X11DRV_DIB_Convert_888_to_555_reverse
3365                         (dstwidth,lines,
3366                          srcbits,-bmpImage->bytes_per_line,
3367                          dstbits,linebytes);
3368                 } else {
3369                     /* ==== rgb 888 bmp -> bgr 565 dib ==== */
3370                     /* ==== bgr 888 bmp -> rgb 565 dib ==== */
3371                     X11DRV_DIB_Convert_888_to_565_reverse
3372                         (dstwidth,lines,
3373                          srcbits,-bmpImage->bytes_per_line,
3374                          dstbits,linebytes);
3375                 }
3376             }
3377             break;
3378         }
3379         /* Fall through */
3380
3381     case 32:
3382         {
3383             const char* srcbits;
3384
3385             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3386
3387             if (bmpImage->green_mask!=0x00ff00 ||
3388                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
3389                 goto notsupported;
3390             } else if ((rDst==0x1f && bmpImage->red_mask==0xff) ||
3391                        (bDst==0x1f && bmpImage->blue_mask==0xff)) {
3392                 if (gDst==0x03e0) {
3393                     /* ==== rgb 0888 bmp -> rgb 555 dib ==== */
3394                     /* ==== bgr 0888 bmp -> bgr 555 dib ==== */
3395                     X11DRV_DIB_Convert_0888_to_555_asis
3396                         (dstwidth,lines,
3397                          srcbits,-bmpImage->bytes_per_line,
3398                          dstbits,linebytes);
3399                 } else {
3400                     /* ==== rgb 0888 bmp -> rgb 565 dib ==== */
3401                     /* ==== bgr 0888 bmp -> bgr 565 dib ==== */
3402                     X11DRV_DIB_Convert_0888_to_565_asis
3403                         (dstwidth,lines,
3404                          srcbits,-bmpImage->bytes_per_line,
3405                          dstbits,linebytes);
3406                 }
3407             } else {
3408                 if (gDst==0x03e0) {
3409                     /* ==== rgb 0888 bmp -> bgr 555 dib ==== */
3410                     /* ==== bgr 0888 bmp -> rgb 555 dib ==== */
3411                     X11DRV_DIB_Convert_0888_to_555_reverse
3412                         (dstwidth,lines,
3413                          srcbits,-bmpImage->bytes_per_line,
3414                          dstbits,linebytes);
3415                 } else {
3416                     /* ==== rgb 0888 bmp -> bgr 565 dib ==== */
3417                     /* ==== bgr 0888 bmp -> rgb 565 dib ==== */
3418                     X11DRV_DIB_Convert_0888_to_565_reverse
3419                         (dstwidth,lines,
3420                          srcbits,-bmpImage->bytes_per_line,
3421                          dstbits,linebytes);
3422                 }
3423             }
3424         }
3425         break;
3426
3427     case 1:
3428     case 4:
3429         if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors) {
3430             /* ==== pal 1 or 4 bmp -> rgb or bgr 555 or 565 dib ==== */
3431             int rShift,gShift,bShift;
3432             WORD* dstpixel;
3433
3434             /* Shift everything 16 bits left so that all shifts are >0,
3435              * even for BGR DIBs. Then a single >> 16 will bring everything
3436              * back into place.
3437              */
3438             rShift=16+X11DRV_DIB_MaskToShift(rDst)-3;
3439             gShift=16+X11DRV_DIB_MaskToShift(gDst)-3;
3440             bShift=16+X11DRV_DIB_MaskToShift(bDst)-3;
3441             if (gDst==0x07e0) {
3442                 /* 6 bits for the green */
3443                 gShift++;
3444             }
3445             rDst=rDst << 16;
3446             gDst=gDst << 16;
3447             bDst=bDst << 16;
3448             for (h = lines - 1; h >= 0; h--) {
3449                 dstpixel=(LPWORD)dstbits;
3450                 for (x = 0; x < dstwidth; x++) {
3451                     PALETTEENTRY srcval;
3452                     DWORD dstval;
3453                     srcval=srccolors[XGetPixel(bmpImage, x, h)];
3454                     dstval=((srcval.peRed   << rShift) & rDst) |
3455                            ((srcval.peGreen << gShift) & gDst) |
3456                            ((srcval.peBlue  << bShift) & bDst);
3457                     *dstpixel++=dstval >> 16;
3458                 }
3459                 dstbits += linebytes;
3460             }
3461         } else {
3462             goto notsupported;
3463         }
3464         break;
3465
3466     case 8:
3467         if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors) {
3468             /* ==== pal 8 bmp -> rgb or bgr 555 or 565 dib ==== */
3469             int rShift,gShift,bShift;
3470             const BYTE* srcbits;
3471             const BYTE* srcpixel;
3472             WORD* dstpixel;
3473
3474             /* Shift everything 16 bits left so that all shifts are >0,
3475              * even for BGR DIBs. Then a single >> 16 will bring everything
3476              * back into place.
3477              */
3478             rShift=16+X11DRV_DIB_MaskToShift(rDst)-3;
3479             gShift=16+X11DRV_DIB_MaskToShift(gDst)-3;
3480             bShift=16+X11DRV_DIB_MaskToShift(bDst)-3;
3481             if (gDst==0x07e0) {
3482                 /* 6 bits for the green */
3483                 gShift++;
3484             }
3485             rDst=rDst << 16;
3486             gDst=gDst << 16;
3487             bDst=bDst << 16;
3488             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3489             for (h=0; h<lines; h++) {
3490                 srcpixel=srcbits;
3491                 dstpixel=(LPWORD)dstbits;
3492                 for (x = 0; x < dstwidth; x++) {
3493                     PALETTEENTRY srcval;
3494                     DWORD dstval;
3495                     srcval=srccolors[(int)*srcpixel++];
3496                     dstval=((srcval.peRed   << rShift) & rDst) |
3497                            ((srcval.peGreen << gShift) & gDst) |
3498                            ((srcval.peBlue  << bShift) & bDst);
3499                     *dstpixel++=dstval >> 16;
3500                 }
3501                 srcbits -= bmpImage->bytes_per_line;
3502                 dstbits += linebytes;
3503             }
3504         } else {
3505             goto notsupported;
3506         }
3507         break;
3508
3509     default:
3510     notsupported:
3511         {
3512             /* ==== any bmp format -> rgb or bgr 555 or 565 dib ==== */
3513             int rShift,gShift,bShift;
3514             WORD* dstpixel;
3515
3516             WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 16 bit DIB (%lx,%lx,%lx)\n",
3517                   bmpImage->depth, bmpImage->red_mask,
3518                   bmpImage->green_mask, bmpImage->blue_mask,
3519                   rDst, gDst, bDst);
3520
3521             /* Shift everything 16 bits left so that all shifts are >0,
3522              * even for BGR DIBs. Then a single >> 16 will bring everything
3523              * back into place.
3524              */
3525             rShift=16+X11DRV_DIB_MaskToShift(rDst)-3;
3526             gShift=16+X11DRV_DIB_MaskToShift(gDst)-3;
3527             bShift=16+X11DRV_DIB_MaskToShift(bDst)-3;
3528             if (gDst==0x07e0) {
3529                 /* 6 bits for the green */
3530                 gShift++;
3531             }
3532             rDst=rDst << 16;
3533             gDst=gDst << 16;
3534             bDst=bDst << 16;
3535             for (h = lines - 1; h >= 0; h--) {
3536                 dstpixel=(LPWORD)dstbits;
3537                 for (x = 0; x < dstwidth; x++) {
3538                     COLORREF srcval;
3539                     DWORD dstval;
3540                     srcval=X11DRV_PALETTE_ToLogical(XGetPixel(bmpImage, x, h));
3541                     dstval=((GetRValue(srcval) << rShift) & rDst) |
3542                            ((GetGValue(srcval) << gShift) & gDst) |
3543                            ((GetBValue(srcval) << bShift) & bDst);
3544                     *dstpixel++=dstval >> 16;
3545                 }
3546                 dstbits += linebytes;
3547             }
3548         }
3549         break;
3550     }
3551 }
3552
3553
3554 /***********************************************************************
3555  *           X11DRV_DIB_SetImageBits_24
3556  *
3557  * SetDIBits for a 24-bit deep DIB.
3558  */
3559 static void X11DRV_DIB_SetImageBits_24( int lines, const BYTE *srcbits,
3560                                  DWORD srcwidth, DWORD dstwidth, int left,
3561                                  X11DRV_PDEVICE *physDev,
3562                                  DWORD rSrc, DWORD gSrc, DWORD bSrc,
3563                                  XImage *bmpImage, DWORD linebytes )
3564 {
3565     DWORD x;
3566     int h;
3567
3568     if (lines < 0 )
3569     {
3570         lines = -lines;
3571         srcbits = srcbits + linebytes * (lines - 1);
3572         linebytes = -linebytes;
3573     }
3574
3575     switch (bmpImage->depth)
3576     {
3577     case 24:
3578         if (bmpImage->bits_per_pixel==24) {
3579             char* dstbits;
3580
3581             srcbits=srcbits+left*3;
3582             dstbits=bmpImage->data+left*3+(lines-1)*bmpImage->bytes_per_line;
3583
3584             if (bmpImage->green_mask!=0x00ff00 ||
3585                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
3586                 goto notsupported;
3587             } else if (rSrc==bmpImage->red_mask) {
3588                 /* ==== rgb 888 dib -> rgb 888 bmp ==== */
3589                 /* ==== bgr 888 dib -> bgr 888 bmp ==== */
3590                 X11DRV_DIB_Convert_any_asis
3591                     (dstwidth,lines,3,
3592                      srcbits,linebytes,
3593                      dstbits,-bmpImage->bytes_per_line);
3594             } else {
3595                 /* ==== rgb 888 dib -> bgr 888 bmp ==== */
3596                 /* ==== bgr 888 dib -> rgb 888 bmp ==== */
3597                 X11DRV_DIB_Convert_888_reverse
3598                     (dstwidth,lines,
3599                      srcbits,linebytes,
3600                      dstbits,-bmpImage->bytes_per_line);
3601             }
3602             break;
3603         }
3604         /* fall through */
3605
3606     case 32:
3607         {
3608             char* dstbits;
3609
3610             srcbits=srcbits+left*3;
3611             dstbits=bmpImage->data+left*4+(lines-1)*bmpImage->bytes_per_line;
3612
3613             if (bmpImage->green_mask!=0x00ff00 ||
3614                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
3615                 goto notsupported;
3616             } else if (rSrc==bmpImage->red_mask) {
3617                 /* ==== rgb 888 dib -> rgb 0888 bmp ==== */
3618                 /* ==== bgr 888 dib -> bgr 0888 bmp ==== */
3619                 X11DRV_DIB_Convert_888_to_0888_asis
3620                     (dstwidth,lines,
3621                      srcbits,linebytes,
3622                      dstbits,-bmpImage->bytes_per_line);
3623             } else {
3624                 /* ==== rgb 888 dib -> bgr 0888 bmp ==== */
3625                 /* ==== bgr 888 dib -> rgb 0888 bmp ==== */
3626                 X11DRV_DIB_Convert_888_to_0888_reverse
3627                     (dstwidth,lines,
3628                      srcbits,linebytes,
3629                      dstbits,-bmpImage->bytes_per_line);
3630             }
3631             break;
3632         }
3633
3634     case 15:
3635     case 16:
3636         {
3637             char* dstbits;
3638
3639             srcbits=srcbits+left*3;
3640             dstbits=bmpImage->data+left*2+(lines-1)*bmpImage->bytes_per_line;
3641
3642             if (bmpImage->green_mask==0x03e0) {
3643                 if ((rSrc==0xff0000 && bmpImage->red_mask==0x7f00) ||
3644                     (bSrc==0xff0000 && bmpImage->blue_mask==0x7f00)) {
3645                     /* ==== rgb 888 dib -> rgb 555 bmp ==== */
3646                     /* ==== bgr 888 dib -> bgr 555 bmp ==== */
3647                     X11DRV_DIB_Convert_888_to_555_asis
3648                         (dstwidth,lines,
3649                          srcbits,linebytes,
3650                          dstbits,-bmpImage->bytes_per_line);
3651                 } else if ((rSrc==0xff && bmpImage->red_mask==0x7f00) ||
3652                            (bSrc==0xff && bmpImage->blue_mask==0x7f00)) {
3653                     /* ==== rgb 888 dib -> bgr 555 bmp ==== */
3654                     /* ==== bgr 888 dib -> rgb 555 bmp ==== */
3655                     X11DRV_DIB_Convert_888_to_555_reverse
3656                         (dstwidth,lines,
3657                          srcbits,linebytes,
3658                          dstbits,-bmpImage->bytes_per_line);
3659                 } else {
3660                     goto notsupported;
3661                 }
3662             } else if (bmpImage->green_mask==0x07e0) {
3663                 if ((rSrc==0xff0000 && bmpImage->red_mask==0xf800) ||
3664                     (bSrc==0xff0000 && bmpImage->blue_mask==0xf800)) {
3665                     /* ==== rgb 888 dib -> rgb 565 bmp ==== */
3666                     /* ==== bgr 888 dib -> bgr 565 bmp ==== */
3667                     X11DRV_DIB_Convert_888_to_565_asis
3668                         (dstwidth,lines,
3669                          srcbits,linebytes,
3670                          dstbits,-bmpImage->bytes_per_line);
3671                 } else if ((rSrc==0xff && bmpImage->red_mask==0xf800) ||
3672                            (bSrc==0xff && bmpImage->blue_mask==0xf800)) {
3673                     /* ==== rgb 888 dib -> bgr 565 bmp ==== */
3674                     /* ==== bgr 888 dib -> rgb 565 bmp ==== */
3675                     X11DRV_DIB_Convert_888_to_565_reverse
3676                         (dstwidth,lines,
3677                          srcbits,linebytes,
3678                          dstbits,-bmpImage->bytes_per_line);
3679                 } else {
3680                     goto notsupported;
3681                 }
3682             } else {
3683                 goto notsupported;
3684             }
3685         }
3686         break;
3687
3688     default:
3689     notsupported:
3690         WARN("from 24 bit DIB (%lx,%lx,%lx) to unknown %d bit bitmap (%lx,%lx,%lx)\n",
3691               rSrc, gSrc, bSrc, bmpImage->bits_per_pixel, bmpImage->red_mask,
3692               bmpImage->green_mask, bmpImage->blue_mask );
3693         /* fall through */
3694     case 1:
3695     case 4:
3696     case 8:
3697         {
3698             /* ==== rgb 888 dib -> any bmp bormat ==== */
3699             const BYTE* srcbyte;
3700
3701             /* Windows only supports one 24bpp DIB format: RGB888 */
3702             srcbits+=left*3;
3703             for (h = lines - 1; h >= 0; h--) {
3704                 srcbyte=(const BYTE*)srcbits;
3705                 for (x = left; x < dstwidth+left; x++) {
3706                     XPutPixel(bmpImage, x, h,
3707                               X11DRV_PALETTE_ToPhysical
3708                               (physDev, RGB(srcbyte[2], srcbyte[1], srcbyte[0])));
3709                     srcbyte+=3;
3710                 }
3711                 srcbits += linebytes;
3712             }
3713         }
3714         break;
3715     }
3716 }
3717
3718
3719 /***********************************************************************
3720  *           X11DRV_DIB_GetImageBits_24
3721  *
3722  * GetDIBits for an 24-bit deep DIB.
3723  */
3724 static void X11DRV_DIB_GetImageBits_24( int lines, BYTE *dstbits,
3725                                         DWORD dstwidth, DWORD srcwidth,
3726                                         PALETTEENTRY *srccolors,
3727                                         DWORD rDst, DWORD gDst, DWORD bDst,
3728                                         XImage *bmpImage, DWORD linebytes )
3729 {
3730     DWORD x;
3731     int h;
3732
3733     if (lines < 0 )
3734     {
3735         lines = -lines;
3736         dstbits = dstbits + ( linebytes * (lines-1) );
3737         linebytes = -linebytes;
3738     }
3739
3740     switch (bmpImage->depth)
3741     {
3742     case 24:
3743         if (bmpImage->bits_per_pixel==24) {
3744             const char* srcbits;
3745
3746             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3747
3748             if (bmpImage->green_mask!=0x00ff00 ||
3749                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
3750                 goto notsupported;
3751             } else if (rDst==bmpImage->red_mask) {
3752                 /* ==== rgb 888 bmp -> rgb 888 dib ==== */
3753                 /* ==== bgr 888 bmp -> bgr 888 dib ==== */
3754                 X11DRV_DIB_Convert_any_asis
3755                     (dstwidth,lines,3,
3756                      srcbits,-bmpImage->bytes_per_line,
3757                      dstbits,linebytes);
3758             } else {
3759                 /* ==== rgb 888 bmp -> bgr 888 dib ==== */
3760                 /* ==== bgr 888 bmp -> rgb 888 dib ==== */
3761                 X11DRV_DIB_Convert_888_reverse
3762                     (dstwidth,lines,
3763                      srcbits,-bmpImage->bytes_per_line,
3764                      dstbits,linebytes);
3765             }
3766             break;
3767         }
3768         /* fall through */
3769
3770     case 32:
3771         {
3772             const char* srcbits;
3773
3774             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3775
3776             if (bmpImage->green_mask!=0x00ff00 ||
3777                 (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
3778                 goto notsupported;
3779             } else if (rDst==bmpImage->red_mask) {
3780                 /* ==== rgb 888 bmp -> rgb 0888 dib ==== */
3781                 /* ==== bgr 888 bmp -> bgr 0888 dib ==== */
3782                 X11DRV_DIB_Convert_0888_to_888_asis
3783                     (dstwidth,lines,
3784                      srcbits,-bmpImage->bytes_per_line,
3785                      dstbits,linebytes);
3786             } else {
3787                 /* ==== rgb 888 bmp -> bgr 0888 dib ==== */
3788                 /* ==== bgr 888 bmp -> rgb 0888 dib ==== */
3789                 X11DRV_DIB_Convert_0888_to_888_reverse
3790                     (dstwidth,lines,
3791                      srcbits,-bmpImage->bytes_per_line,
3792                      dstbits,linebytes);
3793             }
3794             break;
3795         }
3796
3797     case 15:
3798     case 16:
3799         {
3800             const char* srcbits;
3801
3802             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3803
3804             if (bmpImage->green_mask==0x03e0) {
3805                 if ((rDst==0xff0000 && bmpImage->red_mask==0x7f00) ||
3806                     (bDst==0xff0000 && bmpImage->blue_mask==0x7f00)) {
3807                     /* ==== rgb 555 bmp -> rgb 888 dib ==== */
3808                     /* ==== bgr 555 bmp -> bgr 888 dib ==== */
3809                     X11DRV_DIB_Convert_555_to_888_asis
3810                         (dstwidth,lines,
3811                          srcbits,-bmpImage->bytes_per_line,
3812                          dstbits,linebytes);
3813                 } else if ((rDst==0xff && bmpImage->red_mask==0x7f00) ||
3814                            (bDst==0xff && bmpImage->blue_mask==0x7f00)) {
3815                     /* ==== rgb 555 bmp -> bgr 888 dib ==== */
3816                     /* ==== bgr 555 bmp -> rgb 888 dib ==== */
3817                     X11DRV_DIB_Convert_555_to_888_reverse
3818                         (dstwidth,lines,
3819                          srcbits,-bmpImage->bytes_per_line,
3820                          dstbits,linebytes);
3821                 } else {
3822                     goto notsupported;
3823                 }
3824             } else if (bmpImage->green_mask==0x07e0) {
3825                 if ((rDst==0xff0000 && bmpImage->red_mask==0xf800) ||
3826                     (bDst==0xff0000 && bmpImage->blue_mask==0xf800)) {
3827                     /* ==== rgb 565 bmp -> rgb 888 dib ==== */
3828                     /* ==== bgr 565 bmp -> bgr 888 dib ==== */
3829                     X11DRV_DIB_Convert_565_to_888_asis
3830                         (dstwidth,lines,
3831                          srcbits,-bmpImage->bytes_per_line,
3832                          dstbits,linebytes);
3833                 } else if ((rDst==0xff && bmpImage->red_mask==0xf800) ||
3834                            (bDst==0xff && bmpImage->blue_mask==0xf800)) {
3835                     /* ==== rgb 565 bmp -> bgr 888 dib ==== */
3836                     /* ==== bgr 565 bmp -> rgb 888 dib ==== */
3837                     X11DRV_DIB_Convert_565_to_888_reverse
3838                         (dstwidth,lines,
3839                          srcbits,-bmpImage->bytes_per_line,
3840                          dstbits,linebytes);
3841                 } else {
3842                     goto notsupported;
3843                 }
3844             } else {
3845                 goto notsupported;
3846             }
3847         }
3848         break;
3849
3850     case 1:
3851     case 4:
3852         if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors) {
3853             /* ==== pal 1 or 4 bmp -> rgb 888 dib ==== */
3854             BYTE* dstbyte;
3855
3856             /* Windows only supports one 24bpp DIB format: rgb 888 */
3857             for (h = lines - 1; h >= 0; h--) {
3858                 dstbyte=dstbits;
3859                 for (x = 0; x < dstwidth; x++) {
3860                     PALETTEENTRY srcval;
3861                     srcval=srccolors[XGetPixel(bmpImage, x, h)];
3862                     dstbyte[0]=srcval.peBlue;
3863                     dstbyte[1]=srcval.peGreen;
3864                     dstbyte[2]=srcval.peRed;
3865                     dstbyte+=3;
3866                 }
3867                 dstbits += linebytes;
3868             }
3869         } else {
3870             goto notsupported;
3871         }
3872         break;
3873
3874     case 8:
3875         if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask == 0 && srccolors) {
3876             /* ==== pal 8 bmp -> rgb 888 dib ==== */
3877             const void* srcbits;
3878             const BYTE* srcpixel;
3879             BYTE* dstbyte;
3880
3881             /* Windows only supports one 24bpp DIB format: rgb 888 */
3882             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
3883             for (h = lines - 1; h >= 0; h--) {
3884                 srcpixel=srcbits;
3885                 dstbyte=dstbits;
3886                 for (x = 0; x < dstwidth; x++ ) {
3887                     PALETTEENTRY srcval;
3888                     srcval=srccolors[(int)*srcpixel++];
3889                     dstbyte[0]=srcval.peBlue;
3890                     dstbyte[1]=srcval.peGreen;
3891                     dstbyte[2]=srcval.peRed;
3892                     dstbyte+=3;
3893                 }
3894                 srcbits = (char*)srcbits - bmpImage->bytes_per_line;
3895                 dstbits += linebytes;
3896             }
3897         } else {
3898             goto notsupported;
3899         }
3900         break;
3901
3902     default:
3903     notsupported:
3904         {
3905             /* ==== any bmp format -> 888 dib ==== */
3906             BYTE* dstbyte;
3907
3908             WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 24 bit DIB (%lx,%lx,%lx)\n",
3909                   bmpImage->depth, bmpImage->red_mask,
3910                   bmpImage->green_mask, bmpImage->blue_mask,
3911                   rDst, gDst, bDst );
3912
3913             /* Windows only supports one 24bpp DIB format: rgb 888 */
3914             for (h = lines - 1; h >= 0; h--) {
3915                 dstbyte=dstbits;
3916                 for (x = 0; x < dstwidth; x++) {
3917                     COLORREF srcval=X11DRV_PALETTE_ToLogical
3918                         (XGetPixel( bmpImage, x, h ));
3919                     dstbyte[0]=GetBValue(srcval);
3920                     dstbyte[1]=GetGValue(srcval);
3921                     dstbyte[2]=GetRValue(srcval);
3922                     dstbyte+=3;
3923                 }
3924                 dstbits += linebytes;
3925             }
3926         }
3927         break;
3928     }
3929 }
3930
3931
3932 /***********************************************************************
3933  *           X11DRV_DIB_SetImageBits_32
3934  *
3935  * SetDIBits for a 32-bit deep DIB.
3936  */
3937 static void X11DRV_DIB_SetImageBits_32(int lines, const BYTE *srcbits,
3938                                        DWORD srcwidth, DWORD dstwidth, int left,
3939                                        X11DRV_PDEVICE *physDev,
3940                                        DWORD rSrc, DWORD gSrc, DWORD bSrc,
3941                                        XImage *bmpImage,
3942                                        DWORD linebytes)
3943 {
3944     DWORD x, *ptr;
3945     int h;
3946
3947     if (lines < 0 )
3948     {
3949        lines = -lines;
3950        srcbits = srcbits + ( linebytes * (lines-1) );
3951        linebytes = -linebytes;
3952     }
3953
3954     ptr = (DWORD *) srcbits + left;
3955
3956     switch (bmpImage->depth)
3957     {
3958     case 24:
3959         if (bmpImage->bits_per_pixel==24) {
3960             char* dstbits;
3961
3962             srcbits=srcbits+left*4;
3963             dstbits=bmpImage->data+left*3+(lines-1)*bmpImage->bytes_per_line;
3964
3965             if (rSrc==bmpImage->red_mask && gSrc==bmpImage->green_mask && bSrc==bmpImage->blue_mask) {
3966                 /* ==== rgb 0888 dib -> rgb 888 bmp ==== */
3967                 /* ==== bgr 0888 dib -> bgr 888 bmp ==== */
3968                 X11DRV_DIB_Convert_0888_to_888_asis
3969                     (dstwidth,lines,
3970                      srcbits,linebytes,
3971                      dstbits,-bmpImage->bytes_per_line);
3972             } else if (bmpImage->green_mask!=0x00ff00 ||
3973                        (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
3974                 goto notsupported;
3975                 /* the tests below assume sane bmpImage masks */
3976             } else if (rSrc==bmpImage->blue_mask && gSrc==bmpImage->green_mask && bSrc==bmpImage->red_mask) {
3977                 /* ==== rgb 0888 dib -> bgr 888 bmp ==== */
3978                 /* ==== bgr 0888 dib -> rgb 888 bmp ==== */
3979                 X11DRV_DIB_Convert_0888_to_888_reverse
3980                     (dstwidth,lines,
3981                      srcbits,linebytes,
3982                      dstbits,-bmpImage->bytes_per_line);
3983             } else if (bmpImage->blue_mask==0xff) {
3984                 /* ==== any 0888 dib -> rgb 888 bmp ==== */
3985                 X11DRV_DIB_Convert_any0888_to_rgb888
3986                     (dstwidth,lines,
3987                      srcbits,linebytes,
3988                      rSrc,gSrc,bSrc,
3989                      dstbits,-bmpImage->bytes_per_line);
3990             } else {
3991                 /* ==== any 0888 dib -> bgr 888 bmp ==== */
3992                 X11DRV_DIB_Convert_any0888_to_bgr888
3993                     (dstwidth,lines,
3994                      srcbits,linebytes,
3995                      rSrc,gSrc,bSrc,
3996                      dstbits,-bmpImage->bytes_per_line);
3997             }
3998             break;
3999         }
4000         /* fall through */
4001
4002     case 32:
4003         {
4004             char* dstbits;
4005
4006             srcbits=srcbits+left*4;
4007             dstbits=bmpImage->data+left*4+(lines-1)*bmpImage->bytes_per_line;
4008
4009             if (gSrc==bmpImage->green_mask) {
4010                 if (rSrc==bmpImage->red_mask && bSrc==bmpImage->blue_mask) {
4011                     /* ==== rgb 0888 dib -> rgb 0888 bmp ==== */
4012                     /* ==== bgr 0888 dib -> bgr 0888 bmp ==== */
4013                     X11DRV_DIB_Convert_any_asis
4014                         (dstwidth,lines,4,
4015                          srcbits,linebytes,
4016                          dstbits,-bmpImage->bytes_per_line);
4017                 } else if (bmpImage->green_mask!=0x00ff00 ||
4018                            (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
4019                     goto notsupported;
4020                     /* the tests below assume sane bmpImage masks */
4021                 } else if (rSrc==bmpImage->blue_mask && bSrc==bmpImage->red_mask) {
4022                     /* ==== rgb 0888 dib -> bgr 0888 bmp ==== */
4023                     /* ==== bgr 0888 dib -> rgb 0888 bmp ==== */
4024                     X11DRV_DIB_Convert_0888_reverse
4025                         (dstwidth,lines,
4026                          srcbits,linebytes,
4027                          dstbits,-bmpImage->bytes_per_line);
4028                 } else {
4029                     /* ==== any 0888 dib -> any 0888 bmp ==== */
4030                     X11DRV_DIB_Convert_0888_any
4031                         (dstwidth,lines,
4032                          srcbits,linebytes,
4033                          rSrc,gSrc,bSrc,
4034                          dstbits,-bmpImage->bytes_per_line,
4035                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
4036                 }
4037             } else if (bmpImage->green_mask!=0x00ff00 ||
4038                        (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
4039                 goto notsupported;
4040                 /* the tests below assume sane bmpImage masks */
4041             } else {
4042                 /* ==== any 0888 dib -> any 0888 bmp ==== */
4043                 X11DRV_DIB_Convert_0888_any
4044                     (dstwidth,lines,
4045                      srcbits,linebytes,
4046                      rSrc,gSrc,bSrc,
4047                      dstbits,-bmpImage->bytes_per_line,
4048                      bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
4049             }
4050         }
4051         break;
4052
4053     case 15:
4054     case 16:
4055         {
4056             char* dstbits;
4057
4058             srcbits=srcbits+left*4;
4059             dstbits=bmpImage->data+left*2+(lines-1)*bmpImage->bytes_per_line;
4060
4061             if (rSrc==0xff0000 && gSrc==0x00ff00 && bSrc==0x0000ff) {
4062                 if (bmpImage->green_mask==0x03e0) {
4063                     if (bmpImage->red_mask==0x7f00) {
4064                         /* ==== rgb 0888 dib -> rgb 555 bmp ==== */
4065                         X11DRV_DIB_Convert_0888_to_555_asis
4066                             (dstwidth,lines,
4067                              srcbits,linebytes,
4068                              dstbits,-bmpImage->bytes_per_line);
4069                     } else if (bmpImage->blue_mask==0x7f00) {
4070                         /* ==== rgb 0888 dib -> bgr 555 bmp ==== */
4071                         X11DRV_DIB_Convert_0888_to_555_reverse
4072                             (dstwidth,lines,
4073                              srcbits,linebytes,
4074                              dstbits,-bmpImage->bytes_per_line);
4075                     } else {
4076                         goto notsupported;
4077                     }
4078                 } else if (bmpImage->green_mask==0x07e0) {
4079                     if (bmpImage->red_mask==0xf800) {
4080                         /* ==== rgb 0888 dib -> rgb 565 bmp ==== */
4081                         X11DRV_DIB_Convert_0888_to_565_asis
4082                             (dstwidth,lines,
4083                              srcbits,linebytes,
4084                              dstbits,-bmpImage->bytes_per_line);
4085                     } else if (bmpImage->blue_mask==0xf800) {
4086                         /* ==== rgb 0888 dib -> bgr 565 bmp ==== */
4087                         X11DRV_DIB_Convert_0888_to_565_reverse
4088                             (dstwidth,lines,
4089                              srcbits,linebytes,
4090                              dstbits,-bmpImage->bytes_per_line);
4091                     } else {
4092                         goto notsupported;
4093                     }
4094                 } else {
4095                     goto notsupported;
4096                 }
4097             } else if (rSrc==0x0000ff && gSrc==0x00ff00 && bSrc==0xff0000) {
4098                 if (bmpImage->green_mask==0x03e0) {
4099                     if (bmpImage->blue_mask==0x7f00) {
4100                         /* ==== bgr 0888 dib -> bgr 555 bmp ==== */
4101                         X11DRV_DIB_Convert_0888_to_555_asis
4102                             (dstwidth,lines,
4103                              srcbits,linebytes,
4104                              dstbits,-bmpImage->bytes_per_line);
4105                     } else if (bmpImage->red_mask==0x7f00) {
4106                         /* ==== bgr 0888 dib -> rgb 555 bmp ==== */
4107                         X11DRV_DIB_Convert_0888_to_555_reverse
4108                             (dstwidth,lines,
4109                              srcbits,linebytes,
4110                              dstbits,-bmpImage->bytes_per_line);
4111                     } else {
4112                         goto notsupported;
4113                     }
4114                 } else if (bmpImage->green_mask==0x07e0) {
4115                     if (bmpImage->blue_mask==0xf800) {
4116                         /* ==== bgr 0888 dib -> bgr 565 bmp ==== */
4117                         X11DRV_DIB_Convert_0888_to_565_asis
4118                             (dstwidth,lines,
4119                              srcbits,linebytes,
4120                              dstbits,-bmpImage->bytes_per_line);
4121                     } else if (bmpImage->red_mask==0xf800) {
4122                         /* ==== bgr 0888 dib -> rgb 565 bmp ==== */
4123                         X11DRV_DIB_Convert_0888_to_565_reverse
4124                             (dstwidth,lines,
4125                              srcbits,linebytes,
4126                              dstbits,-bmpImage->bytes_per_line);
4127                     } else {
4128                         goto notsupported;
4129                     }
4130                 } else {
4131                     goto notsupported;
4132                 }
4133             } else {
4134                 if (bmpImage->green_mask==0x03e0 &&
4135                     (bmpImage->red_mask==0x7f00 ||
4136                      bmpImage->blue_mask==0x7f00)) {
4137                     /* ==== any 0888 dib -> rgb or bgr 555 bmp ==== */
4138                     X11DRV_DIB_Convert_any0888_to_5x5
4139                         (dstwidth,lines,
4140                          srcbits,linebytes,
4141                          rSrc,gSrc,bSrc,
4142                          dstbits,-bmpImage->bytes_per_line,
4143                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
4144                 } else if (bmpImage->green_mask==0x07e0 &&
4145                            (bmpImage->red_mask==0xf800 ||
4146                             bmpImage->blue_mask==0xf800)) {
4147                     /* ==== any 0888 dib -> rgb or bgr 565 bmp ==== */
4148                     X11DRV_DIB_Convert_any0888_to_5x5
4149                         (dstwidth,lines,
4150                          srcbits,linebytes,
4151                          rSrc,gSrc,bSrc,
4152                          dstbits,-bmpImage->bytes_per_line,
4153                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
4154                 } else {
4155                     goto notsupported;
4156                 }
4157             }
4158         }
4159         break;
4160
4161     default:
4162     notsupported:
4163         WARN("from 32 bit DIB (%lx,%lx,%lx) to unknown %d bit bitmap (%lx,%lx,%lx)\n",
4164               rSrc, gSrc, bSrc, bmpImage->bits_per_pixel, bmpImage->red_mask,
4165               bmpImage->green_mask, bmpImage->blue_mask );
4166         /* fall through */
4167     case 1:
4168     case 4:
4169     case 8:
4170         {
4171             /* ==== any 0888 dib -> pal 1, 4 or 8 bmp ==== */
4172             const DWORD* srcpixel;
4173             int rShift,gShift,bShift;
4174
4175             rShift=X11DRV_DIB_MaskToShift(rSrc);
4176             gShift=X11DRV_DIB_MaskToShift(gSrc);
4177             bShift=X11DRV_DIB_MaskToShift(bSrc);
4178             srcbits+=left*4;
4179             for (h = lines - 1; h >= 0; h--) {
4180                 srcpixel=(const DWORD*)srcbits;
4181                 for (x = left; x < dstwidth+left; x++) {
4182                     DWORD srcvalue;
4183                     BYTE red,green,blue;
4184                     srcvalue=*srcpixel++;
4185                     red=  (srcvalue >> rShift) & 0xff;
4186                     green=(srcvalue >> gShift) & 0xff;
4187                     blue= (srcvalue >> bShift) & 0xff;
4188                     XPutPixel(bmpImage, x, h, X11DRV_PALETTE_ToPhysical
4189                               (physDev, RGB(red,green,blue)));
4190                 }
4191                 srcbits += linebytes;
4192             }
4193         }
4194         break;
4195     }
4196
4197 }
4198
4199 /***********************************************************************
4200  *           X11DRV_DIB_GetImageBits_32
4201  *
4202  * GetDIBits for an 32-bit deep DIB.
4203  */
4204 static void X11DRV_DIB_GetImageBits_32( int lines, BYTE *dstbits,
4205                                         DWORD dstwidth, DWORD srcwidth,
4206                                         PALETTEENTRY *srccolors,
4207                                         DWORD rDst, DWORD gDst, DWORD bDst,
4208                                         XImage *bmpImage, DWORD linebytes )
4209 {
4210     DWORD x;
4211     int h;
4212     BYTE *bits;
4213
4214     if (lines < 0 )
4215     {
4216         lines = -lines;
4217         dstbits = dstbits + ( linebytes * (lines-1) );
4218         linebytes = -linebytes;
4219     }
4220
4221     bits = dstbits;
4222
4223     switch (bmpImage->depth)
4224     {
4225     case 24:
4226         if (bmpImage->bits_per_pixel==24) {
4227             const void* srcbits;
4228
4229             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
4230
4231             if (rDst==bmpImage->red_mask && gDst==bmpImage->green_mask && bDst==bmpImage->blue_mask) {
4232                 /* ==== rgb 888 bmp -> rgb 0888 dib ==== */
4233                 /* ==== bgr 888 bmp -> bgr 0888 dib ==== */
4234                 X11DRV_DIB_Convert_888_to_0888_asis
4235                     (dstwidth,lines,
4236                      srcbits,-bmpImage->bytes_per_line,
4237                      dstbits,linebytes);
4238             } else if (bmpImage->green_mask!=0x00ff00 ||
4239                        (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
4240                 goto notsupported;
4241                 /* the tests below assume sane bmpImage masks */
4242             } else if (rDst==bmpImage->blue_mask && gDst==bmpImage->green_mask && bDst==bmpImage->red_mask) {
4243                 /* ==== rgb 888 bmp -> bgr 0888 dib ==== */
4244                 /* ==== bgr 888 bmp -> rgb 0888 dib ==== */
4245                 X11DRV_DIB_Convert_888_to_0888_reverse
4246                     (dstwidth,lines,
4247                      srcbits,-bmpImage->bytes_per_line,
4248                      dstbits,linebytes);
4249             } else if (bmpImage->blue_mask==0xff) {
4250                 /* ==== rgb 888 bmp -> any 0888 dib ==== */
4251                 X11DRV_DIB_Convert_rgb888_to_any0888
4252                     (dstwidth,lines,
4253                      srcbits,-bmpImage->bytes_per_line,
4254                      dstbits,linebytes,
4255                      rDst,gDst,bDst);
4256             } else {
4257                 /* ==== bgr 888 bmp -> any 0888 dib ==== */
4258                 X11DRV_DIB_Convert_bgr888_to_any0888
4259                     (dstwidth,lines,
4260                      srcbits,-bmpImage->bytes_per_line,
4261                      dstbits,linebytes,
4262                      rDst,gDst,bDst);
4263             }
4264             break;
4265         }
4266         /* fall through */
4267
4268     case 32:
4269         {
4270             const char* srcbits;
4271
4272             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
4273
4274             if (gDst==bmpImage->green_mask) {
4275                 if (rDst==bmpImage->red_mask && bDst==bmpImage->blue_mask) {
4276                     /* ==== rgb 0888 bmp -> rgb 0888 dib ==== */
4277                     /* ==== bgr 0888 bmp -> bgr 0888 dib ==== */
4278                     X11DRV_DIB_Convert_any_asis
4279                         (dstwidth,lines,4,
4280                          srcbits,-bmpImage->bytes_per_line,
4281                          dstbits,linebytes);
4282                 } else if (bmpImage->green_mask!=0x00ff00 ||
4283                            (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
4284                     goto notsupported;
4285                     /* the tests below assume sane bmpImage masks */
4286                 } else if (rDst==bmpImage->blue_mask && bDst==bmpImage->red_mask) {
4287                     /* ==== rgb 0888 bmp -> bgr 0888 dib ==== */
4288                     /* ==== bgr 0888 bmp -> rgb 0888 dib ==== */
4289                     X11DRV_DIB_Convert_0888_reverse
4290                         (dstwidth,lines,
4291                          srcbits,-bmpImage->bytes_per_line,
4292                          dstbits,linebytes);
4293                 } else {
4294                     /* ==== any 0888 bmp -> any 0888 dib ==== */
4295                     X11DRV_DIB_Convert_0888_any
4296                         (dstwidth,lines,
4297                          srcbits,-bmpImage->bytes_per_line,
4298                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask,
4299                          dstbits,linebytes,
4300                          rDst,gDst,bDst);
4301                 }
4302             } else if (bmpImage->green_mask!=0x00ff00 ||
4303                        (bmpImage->red_mask|bmpImage->blue_mask)!=0xff00ff) {
4304                 goto notsupported;
4305                 /* the tests below assume sane bmpImage masks */
4306             } else {
4307                 /* ==== any 0888 bmp -> any 0888 dib ==== */
4308                 X11DRV_DIB_Convert_0888_any
4309                     (dstwidth,lines,
4310                      srcbits,-bmpImage->bytes_per_line,
4311                      bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask,
4312                      dstbits,linebytes,
4313                      rDst,gDst,bDst);
4314             }
4315         }
4316         break;
4317
4318     case 15:
4319     case 16:
4320         {
4321             const char* srcbits;
4322
4323             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
4324
4325             if (rDst==0xff0000 && gDst==0x00ff00 && bDst==0x0000ff) {
4326                 if (bmpImage->green_mask==0x03e0) {
4327                     if (bmpImage->red_mask==0x7f00) {
4328                         /* ==== rgb 555 bmp -> rgb 0888 dib ==== */
4329                         X11DRV_DIB_Convert_555_to_0888_asis
4330                             (dstwidth,lines,
4331                              srcbits,-bmpImage->bytes_per_line,
4332                              dstbits,linebytes);
4333                     } else if (bmpImage->blue_mask==0x7f00) {
4334                         /* ==== bgr 555 bmp -> rgb 0888 dib ==== */
4335                         X11DRV_DIB_Convert_555_to_0888_reverse
4336                             (dstwidth,lines,
4337                              srcbits,-bmpImage->bytes_per_line,
4338                              dstbits,linebytes);
4339                     } else {
4340                         goto notsupported;
4341                     }
4342                 } else if (bmpImage->green_mask==0x07e0) {
4343                     if (bmpImage->red_mask==0xf800) {
4344                         /* ==== rgb 565 bmp -> rgb 0888 dib ==== */
4345                         X11DRV_DIB_Convert_565_to_0888_asis
4346                             (dstwidth,lines,
4347                              srcbits,-bmpImage->bytes_per_line,
4348                              dstbits,linebytes);
4349                     } else if (bmpImage->blue_mask==0xf800) {
4350                         /* ==== bgr 565 bmp -> rgb 0888 dib ==== */
4351                         X11DRV_DIB_Convert_565_to_0888_reverse
4352                             (dstwidth,lines,
4353                              srcbits,-bmpImage->bytes_per_line,
4354                              dstbits,linebytes);
4355                     } else {
4356                         goto notsupported;
4357                     }
4358                 } else {
4359                     goto notsupported;
4360                 }
4361             } else if (rDst==0x0000ff && gDst==0x00ff00 && bDst==0xff0000) {
4362                 if (bmpImage->green_mask==0x03e0) {
4363                     if (bmpImage->blue_mask==0x7f00) {
4364                         /* ==== bgr 555 bmp -> bgr 0888 dib ==== */
4365                         X11DRV_DIB_Convert_555_to_0888_asis
4366                             (dstwidth,lines,
4367                              srcbits,-bmpImage->bytes_per_line,
4368                              dstbits,linebytes);
4369                     } else if (bmpImage->red_mask==0x7f00) {
4370                         /* ==== rgb 555 bmp -> bgr 0888 dib ==== */
4371                         X11DRV_DIB_Convert_555_to_0888_reverse
4372                             (dstwidth,lines,
4373                              srcbits,-bmpImage->bytes_per_line,
4374                              dstbits,linebytes);
4375                     } else {
4376                         goto notsupported;
4377                     }
4378                 } else if (bmpImage->green_mask==0x07e0) {
4379                     if (bmpImage->blue_mask==0xf800) {
4380                         /* ==== bgr 565 bmp -> bgr 0888 dib ==== */
4381                         X11DRV_DIB_Convert_565_to_0888_asis
4382                             (dstwidth,lines,
4383                              srcbits,-bmpImage->bytes_per_line,
4384                              dstbits,linebytes);
4385                     } else if (bmpImage->red_mask==0xf800) {
4386                         /* ==== rgb 565 bmp -> bgr 0888 dib ==== */
4387                         X11DRV_DIB_Convert_565_to_0888_reverse
4388                             (dstwidth,lines,
4389                              srcbits,-bmpImage->bytes_per_line,
4390                              dstbits,linebytes);
4391                     } else {
4392                         goto notsupported;
4393                     }
4394                 } else {
4395                     goto notsupported;
4396                 }
4397             } else {
4398                 if (bmpImage->green_mask==0x03e0 &&
4399                     (bmpImage->red_mask==0x7f00 ||
4400                      bmpImage->blue_mask==0x7f00)) {
4401                     /* ==== rgb or bgr 555 bmp -> any 0888 dib ==== */
4402                     X11DRV_DIB_Convert_5x5_to_any0888
4403                         (dstwidth,lines,
4404                          srcbits,-bmpImage->bytes_per_line,
4405                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask,
4406                          dstbits,linebytes,
4407                          rDst,gDst,bDst);
4408                 } else if (bmpImage->green_mask==0x07e0 &&
4409                            (bmpImage->red_mask==0xf800 ||
4410                             bmpImage->blue_mask==0xf800)) {
4411                     /* ==== rgb or bgr 565 bmp -> any 0888 dib ==== */
4412                     X11DRV_DIB_Convert_5x5_to_any0888
4413                         (dstwidth,lines,
4414                          srcbits,-bmpImage->bytes_per_line,
4415                          bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask,
4416                          dstbits,linebytes,
4417                          rDst,gDst,bDst);
4418                 } else {
4419                     goto notsupported;
4420                 }
4421             }
4422         }
4423         break;
4424
4425     case 1:
4426     case 4:
4427         if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors) {
4428             /* ==== pal 1 or 4 bmp -> any 0888 dib ==== */
4429             int rShift,gShift,bShift;
4430             DWORD* dstpixel;
4431
4432             rShift=X11DRV_DIB_MaskToShift(rDst);
4433             gShift=X11DRV_DIB_MaskToShift(gDst);
4434             bShift=X11DRV_DIB_MaskToShift(bDst);
4435             for (h = lines - 1; h >= 0; h--) {
4436                 dstpixel=(DWORD*)dstbits;
4437                 for (x = 0; x < dstwidth; x++) {
4438                     PALETTEENTRY srcval;
4439                     srcval = srccolors[XGetPixel(bmpImage, x, h)];
4440                     *dstpixel++=(srcval.peRed   << rShift) |
4441                                 (srcval.peGreen << gShift) |
4442                                 (srcval.peBlue  << bShift);
4443                 }
4444                 dstbits += linebytes;
4445             }
4446         } else {
4447             goto notsupported;
4448         }
4449         break;
4450
4451     case 8:
4452         if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors) {
4453             /* ==== pal 8 bmp -> any 0888 dib ==== */
4454             int rShift,gShift,bShift;
4455             const void* srcbits;
4456             const BYTE* srcpixel;
4457             DWORD* dstpixel;
4458
4459             rShift=X11DRV_DIB_MaskToShift(rDst);
4460             gShift=X11DRV_DIB_MaskToShift(gDst);
4461             bShift=X11DRV_DIB_MaskToShift(bDst);
4462             srcbits=bmpImage->data+(lines-1)*bmpImage->bytes_per_line;
4463             for (h = lines - 1; h >= 0; h--) {
4464                 srcpixel=srcbits;
4465                 dstpixel=(DWORD*)dstbits;
4466                 for (x = 0; x < dstwidth; x++) {
4467                     PALETTEENTRY srcval;
4468                     srcval=srccolors[(int)*srcpixel++];
4469                     *dstpixel++=(srcval.peRed   << rShift) |
4470                                 (srcval.peGreen << gShift) |
4471                                 (srcval.peBlue  << bShift);
4472                 }
4473                 srcbits = (char*)srcbits - bmpImage->bytes_per_line;
4474                 dstbits += linebytes;
4475             }
4476         } else {
4477             goto notsupported;
4478         }
4479         break;
4480
4481     default:
4482     notsupported:
4483         {
4484             /* ==== any bmp format -> any 0888 dib ==== */
4485             int rShift,gShift,bShift;
4486             DWORD* dstpixel;
4487
4488             WARN("from unknown %d bit bitmap (%lx,%lx,%lx) to 32 bit DIB (%lx,%lx,%lx)\n",
4489                   bmpImage->depth, bmpImage->red_mask,
4490                   bmpImage->green_mask, bmpImage->blue_mask,
4491                   rDst,gDst,bDst);
4492
4493             rShift=X11DRV_DIB_MaskToShift(rDst);
4494             gShift=X11DRV_DIB_MaskToShift(gDst);
4495             bShift=X11DRV_DIB_MaskToShift(bDst);
4496             for (h = lines - 1; h >= 0; h--) {
4497                 dstpixel=(DWORD*)dstbits;
4498                 for (x = 0; x < dstwidth; x++) {
4499                     COLORREF srcval;
4500                     srcval=X11DRV_PALETTE_ToLogical(XGetPixel(bmpImage, x, h));
4501                     *dstpixel++=(GetRValue(srcval) << rShift) |
4502                                 (GetGValue(srcval) << gShift) |
4503                                 (GetBValue(srcval) << bShift);
4504                 }
4505                 dstbits += linebytes;
4506             }
4507         }
4508         break;
4509     }
4510 }
4511
4512 /***********************************************************************
4513  *           X11DRV_DIB_SetImageBits
4514  *
4515  * Transfer the bits to an X image.
4516  * Helper function for SetDIBits() and SetDIBitsToDevice().
4517  */
4518 static int X11DRV_DIB_SetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
4519 {
4520     int lines = descr->lines >= 0 ? descr->lines : -descr->lines;
4521     XImage *bmpImage;
4522
4523     wine_tsx11_lock();
4524     if (descr->image)
4525         bmpImage = descr->image;
4526     else {
4527         bmpImage = XCreateImage( gdi_display, visual, descr->depth, ZPixmap, 0, NULL,
4528                                  descr->infoWidth, lines, 32, 0 );
4529         bmpImage->data = calloc( lines, bmpImage->bytes_per_line );
4530         if(bmpImage->data == NULL) {
4531             ERR("Out of memory!\n");
4532             XDestroyImage( bmpImage );
4533             wine_tsx11_unlock();
4534             return lines;
4535         }
4536     }
4537
4538     TRACE("Dib: depth=%d r=%lx g=%lx b=%lx\n",
4539           descr->infoBpp,descr->rMask,descr->gMask,descr->bMask);
4540     TRACE("Bmp: depth=%d/%d r=%lx g=%lx b=%lx\n",
4541           bmpImage->depth,bmpImage->bits_per_pixel,
4542           bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
4543
4544       /* Transfer the pixels */
4545     switch(descr->infoBpp)
4546     {
4547     case 1:
4548         X11DRV_DIB_SetImageBits_1( descr->lines, descr->bits, descr->infoWidth,
4549                                    descr->width, descr->xSrc, (int *)(descr->colorMap),
4550                                    bmpImage, descr->dibpitch );
4551         break;
4552     case 4:
4553         if (descr->compression) {
4554             XGetSubImage( gdi_display, descr->drawable, descr->xDest, descr->yDest,
4555                           descr->width, descr->height, AllPlanes, ZPixmap,
4556                           bmpImage, descr->xSrc, descr->ySrc );
4557
4558             X11DRV_DIB_SetImageBits_RLE4( descr->lines, descr->bits,
4559                                           descr->infoWidth, descr->width,
4560                                           descr->xSrc, (int *)(descr->colorMap),
4561                                           bmpImage );
4562         } else
4563             X11DRV_DIB_SetImageBits_4( descr->lines, descr->bits,
4564                                        descr->infoWidth, descr->width,
4565                                        descr->xSrc, (int*)(descr->colorMap),
4566                                        bmpImage, descr->dibpitch );
4567         break;
4568     case 8:
4569         if (descr->compression) {
4570             XGetSubImage( gdi_display, descr->drawable, descr->xDest, descr->yDest,
4571                           descr->width, descr->height, AllPlanes, ZPixmap,
4572                           bmpImage, descr->xSrc, descr->ySrc );
4573             X11DRV_DIB_SetImageBits_RLE8( descr->lines, descr->bits,
4574                                           descr->infoWidth, descr->width,
4575                                           descr->xSrc, (int *)(descr->colorMap),
4576                                           bmpImage );
4577         } else
4578             X11DRV_DIB_SetImageBits_8( descr->lines, descr->bits,
4579                                        descr->infoWidth, descr->width,
4580                                        descr->xSrc, (int *)(descr->colorMap),
4581                                        bmpImage, descr->dibpitch );
4582         break;
4583     case 15:
4584     case 16:
4585         X11DRV_DIB_SetImageBits_16( descr->lines, descr->bits,
4586                                     descr->infoWidth, descr->width,
4587                                    descr->xSrc, descr->physDev,
4588                                    descr->rMask, descr->gMask, descr->bMask,
4589                                    bmpImage, descr->dibpitch);
4590         break;
4591     case 24:
4592         X11DRV_DIB_SetImageBits_24( descr->lines, descr->bits,
4593                                     descr->infoWidth, descr->width,
4594                                     descr->xSrc, descr->physDev,
4595                                     descr->rMask, descr->gMask, descr->bMask,
4596                                     bmpImage, descr->dibpitch);
4597         break;
4598     case 32:
4599         X11DRV_DIB_SetImageBits_32( descr->lines, descr->bits,
4600                                     descr->infoWidth, descr->width,
4601                                    descr->xSrc, descr->physDev,
4602                                    descr->rMask, descr->gMask, descr->bMask,
4603                                    bmpImage, descr->dibpitch);
4604         break;
4605     default:
4606         WARN("(%d): Invalid depth\n", descr->infoBpp );
4607         break;
4608     }
4609
4610     TRACE("XPutImage(%ld,%p,%p,%d,%d,%d,%d,%d,%d)\n",
4611      descr->drawable, descr->gc, bmpImage,
4612      descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
4613      descr->width, descr->height);
4614 #ifdef HAVE_LIBXXSHM
4615     if (descr->useShm)
4616     {
4617         XShmPutImage( gdi_display, descr->drawable, descr->gc, bmpImage,
4618                       descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
4619                       descr->width, descr->height, FALSE );
4620         XSync( gdi_display, 0 );
4621     }
4622     else
4623 #endif
4624         XPutImage( gdi_display, descr->drawable, descr->gc, bmpImage,
4625                    descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
4626                    descr->width, descr->height );
4627
4628     if (!descr->image) XDestroyImage( bmpImage );
4629     wine_tsx11_unlock();
4630     return lines;
4631 }
4632
4633 /***********************************************************************
4634  *           X11DRV_DIB_GetImageBits
4635  *
4636  * Transfer the bits from an X image.
4637  */
4638 static int X11DRV_DIB_GetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
4639 {
4640     int lines = descr->lines >= 0 ? descr->lines : -descr->lines;
4641     XImage *bmpImage;
4642
4643     wine_tsx11_lock();
4644    if (descr->image)
4645         bmpImage = descr->image;
4646     else {
4647         bmpImage = XCreateImage( gdi_display, visual, descr->depth, ZPixmap, 0, NULL,
4648                                  descr->infoWidth, lines, 32, 0 );
4649         bmpImage->data = calloc( lines, bmpImage->bytes_per_line );
4650         if(bmpImage->data == NULL) {
4651             ERR("Out of memory!\n");
4652             XDestroyImage( bmpImage );
4653             wine_tsx11_unlock();
4654             return lines;
4655         }
4656     }
4657
4658 #ifdef HAVE_LIBXXSHM
4659     if (descr->useShm)
4660     {
4661         int saveRed, saveGreen, saveBlue;
4662
4663         TRACE("XShmGetImage(%p, %ld, %p, %d, %d, %ld)\n",
4664                             gdi_display, descr->drawable, bmpImage,
4665                             descr->xSrc, descr->ySrc, AllPlanes);
4666
4667         /* We must save and restore the bmpImage's masks in order
4668          * to preserve them across the call to XShmGetImage, which
4669          * decides to eleminate them since it doesn't happen to know
4670          * what the format of the image is supposed to be, even though
4671          * we do. */
4672         saveRed = bmpImage->red_mask;
4673         saveBlue= bmpImage->blue_mask;
4674         saveGreen = bmpImage->green_mask;
4675
4676         XShmGetImage( gdi_display, descr->drawable, bmpImage,
4677                       descr->xSrc, descr->ySrc, AllPlanes);
4678
4679         bmpImage->red_mask = saveRed;
4680         bmpImage->blue_mask = saveBlue;
4681         bmpImage->green_mask = saveGreen;
4682     }
4683     else
4684 #endif /* HAVE_LIBXXSHM */
4685     {
4686         TRACE("XGetSubImage(%p,%ld,%d,%d,%d,%d,%ld,%d,%p,%d,%d)\n",
4687               gdi_display, descr->drawable, descr->xSrc, descr->ySrc, descr->width,
4688               lines, AllPlanes, ZPixmap, bmpImage, descr->xDest, descr->yDest);
4689         XGetSubImage( gdi_display, descr->drawable, descr->xSrc, descr->ySrc,
4690                       descr->width, lines, AllPlanes, ZPixmap,
4691                       bmpImage, descr->xDest, descr->yDest );
4692     }
4693
4694     TRACE("Dib: depth=%2d r=%lx g=%lx b=%lx\n",
4695           descr->infoBpp,descr->rMask,descr->gMask,descr->bMask);
4696     TRACE("Bmp: depth=%2d/%2d r=%lx g=%lx b=%lx\n",
4697           bmpImage->depth,bmpImage->bits_per_pixel,
4698           bmpImage->red_mask,bmpImage->green_mask,bmpImage->blue_mask);
4699       /* Transfer the pixels */
4700     switch(descr->infoBpp)
4701     {
4702     case 1:
4703           X11DRV_DIB_GetImageBits_1( descr->lines,(LPVOID)descr->bits,
4704                                      descr->infoWidth, descr->width,
4705                                      descr->colorMap, descr->palentry,
4706                                      bmpImage, descr->dibpitch );
4707        break;
4708
4709     case 4:
4710        if (descr->compression)
4711            FIXME("Compression not yet supported!\n");
4712        else
4713            X11DRV_DIB_GetImageBits_4( descr->lines,(LPVOID)descr->bits,
4714                                       descr->infoWidth, descr->width,
4715                                       descr->colorMap, descr->palentry,
4716                                       bmpImage, descr->dibpitch );
4717        break;
4718
4719     case 8:
4720        if (descr->compression)
4721            FIXME("Compression not yet supported!\n");
4722        else
4723            X11DRV_DIB_GetImageBits_8( descr->lines, (LPVOID)descr->bits,
4724                                       descr->infoWidth, descr->width,
4725                                       descr->colorMap, descr->palentry,
4726                                       bmpImage, descr->dibpitch );
4727        break;
4728     case 15:
4729     case 16:
4730        X11DRV_DIB_GetImageBits_16( descr->lines, (LPVOID)descr->bits,
4731                                    descr->infoWidth,descr->width,
4732                                    descr->palentry,
4733                                    descr->rMask, descr->gMask, descr->bMask,
4734                                    bmpImage, descr->dibpitch );
4735        break;
4736
4737     case 24:
4738        X11DRV_DIB_GetImageBits_24( descr->lines, (LPVOID)descr->bits,
4739                                    descr->infoWidth,descr->width,
4740                                    descr->palentry,
4741                                    descr->rMask, descr->gMask, descr->bMask,
4742                                    bmpImage, descr->dibpitch);
4743        break;
4744
4745     case 32:
4746        X11DRV_DIB_GetImageBits_32( descr->lines, (LPVOID)descr->bits,
4747                                    descr->infoWidth, descr->width,
4748                                    descr->palentry,
4749                                    descr->rMask, descr->gMask, descr->bMask,
4750                                    bmpImage, descr->dibpitch);
4751        break;
4752
4753     default:
4754         WARN("(%d): Invalid depth\n", descr->infoBpp );
4755         break;
4756     }
4757
4758     if (!descr->image) XDestroyImage( bmpImage );
4759     wine_tsx11_unlock();
4760     return lines;
4761 }
4762
4763 /*************************************************************************
4764  *              X11DRV_SetDIBitsToDevice
4765  *
4766  */
4767 INT X11DRV_SetDIBitsToDevice( X11DRV_PDEVICE *physDev, INT xDest, INT yDest, DWORD cx,
4768                                 DWORD cy, INT xSrc, INT ySrc,
4769                                 UINT startscan, UINT lines, LPCVOID bits,
4770                                 const BITMAPINFO *info, UINT coloruse )
4771 {
4772     X11DRV_DIB_IMAGEBITS_DESCR descr;
4773     DWORD width;
4774     INT result;
4775     int height;
4776     BOOL top_down;
4777     POINT pt;
4778     DC *dc = physDev->dc;
4779
4780     if (DIB_GetBitmapInfo( &info->bmiHeader, &width, &height,
4781                            &descr.infoBpp, &descr.compression ) == -1)
4782         return 0;
4783     top_down = (height < 0);
4784     if (top_down) height = -height;
4785
4786     pt.x = xDest;
4787     pt.y = yDest;
4788     LPtoDP(physDev->hdc, &pt, 1);
4789
4790     if (!lines || (startscan >= height)) return 0;
4791     if (!top_down && startscan + lines > height) lines = height - startscan;
4792
4793     /* make xSrc,ySrc point to the upper-left corner, not the lower-left one,
4794      * and clamp all values to fit inside [startscan,startscan+lines]
4795      */
4796     if (ySrc + cy <= startscan + lines)
4797     {
4798         INT y = startscan + lines - (ySrc + cy);
4799         if (ySrc < startscan) cy -= (startscan - ySrc);
4800         if (!top_down)
4801         {
4802             /* avoid getting unnecessary lines */
4803             ySrc = 0;
4804             if (y >= lines) return 0;
4805             lines -= y;
4806         }
4807         else
4808         {
4809             if (y >= lines) return lines;
4810             ySrc = y;  /* need to get all lines in top down mode */
4811         }
4812     }
4813     else
4814     {
4815         if (ySrc >= startscan + lines) return lines;
4816         pt.y += ySrc + cy - (startscan + lines);
4817         cy = startscan + lines - ySrc;
4818         ySrc = 0;
4819         if (cy > lines) cy = lines;
4820     }
4821     if (xSrc >= width) return lines;
4822     if (xSrc + cx >= width) cx = width - xSrc;
4823     if (!cx || !cy) return lines;
4824
4825     X11DRV_SetupGCForText( physDev );  /* To have the correct colors */
4826     TSXSetFunction(gdi_display, physDev->gc, X11DRV_XROPfunction[dc->ROPmode-1]);
4827
4828     switch (descr.infoBpp)
4829     {
4830        case 1:
4831        case 4:
4832        case 8:
4833                descr.colorMap = (RGBQUAD *)X11DRV_DIB_BuildColorMap(
4834                                             coloruse == DIB_PAL_COLORS ? physDev : NULL, coloruse,
4835                                             dc->bitsPerPixel, info, &descr.nColorMap );
4836                if (!descr.colorMap) return 0;
4837                descr.rMask = descr.gMask = descr.bMask = 0;
4838                break;
4839        case 15:
4840        case 16:
4841                descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors : 0x7c00;
4842                descr.gMask = (descr.compression == BI_BITFIELDS) ?  *((DWORD *)info->bmiColors + 1) : 0x03e0;
4843                descr.bMask = (descr.compression == BI_BITFIELDS) ?  *((DWORD *)info->bmiColors + 2) : 0x001f;
4844                descr.colorMap = 0;
4845                break;
4846
4847        case 24:
4848        case 32:
4849                descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors       : 0xff0000;
4850                descr.gMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 1) : 0x00ff00;
4851                descr.bMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 2) : 0x0000ff;
4852                descr.colorMap = 0;
4853                break;
4854     }
4855
4856     descr.physDev   = physDev;
4857     descr.bits      = bits;
4858     descr.image     = NULL;
4859     descr.palentry  = NULL;
4860     descr.lines     = top_down ? -lines : lines;
4861     descr.infoWidth = width;
4862     descr.depth     = dc->bitsPerPixel;
4863     descr.drawable  = physDev->drawable;
4864     descr.gc        = physDev->gc;
4865     descr.xSrc      = xSrc;
4866     descr.ySrc      = ySrc;
4867     descr.xDest     = physDev->org.x + pt.x;
4868     descr.yDest     = physDev->org.y + pt.y;
4869     descr.width     = cx;
4870     descr.height    = cy;
4871     descr.useShm    = FALSE;
4872     descr.dibpitch  = ((width * descr.infoBpp + 31) &~31) / 8;
4873
4874     result = X11DRV_DIB_SetImageBits( &descr );
4875
4876     if (descr.infoBpp <= 8)
4877        HeapFree(GetProcessHeap(), 0, descr.colorMap);
4878     return result;
4879 }
4880
4881 /***********************************************************************
4882  *           SetDIBits   (X11DRV.@)
4883  */
4884 INT X11DRV_SetDIBits( X11DRV_PDEVICE *physDev, HBITMAP hbitmap, UINT startscan,
4885                       UINT lines, LPCVOID bits, const BITMAPINFO *info, UINT coloruse )
4886 {
4887   X11DRV_DIB_IMAGEBITS_DESCR descr;
4888   BITMAPOBJ *bmp;
4889   int height, tmpheight;
4890   INT result;
4891
4892   descr.physDev = physDev;
4893
4894   if (DIB_GetBitmapInfo( &info->bmiHeader, &descr.infoWidth, &height,
4895                          &descr.infoBpp, &descr.compression ) == -1)
4896       return 0;
4897
4898   tmpheight = height;
4899   if (height < 0) height = -height;
4900   if (!lines || (startscan >= height))
4901       return 0;
4902
4903   if (!(bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC ))) return 0;
4904
4905   if (startscan + lines > height) lines = height - startscan;
4906
4907   switch (descr.infoBpp)
4908   {
4909        case 1:
4910        case 4:
4911        case 8:
4912                descr.colorMap = (RGBQUAD *)X11DRV_DIB_BuildColorMap(
4913                         coloruse == DIB_PAL_COLORS ? descr.physDev : NULL, coloruse,
4914                                                           bmp->bitmap.bmBitsPixel,
4915                                                           info, &descr.nColorMap );
4916                if (!descr.colorMap)
4917                {
4918                    GDI_ReleaseObj( hbitmap );
4919                    return 0;
4920                }
4921                descr.rMask = descr.gMask = descr.bMask = 0;
4922                break;
4923        case 15:
4924        case 16:
4925                descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors : 0x7c00;
4926                descr.gMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 1) : 0x03e0;
4927                descr.bMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 2) : 0x001f;
4928                descr.colorMap = 0;
4929                break;
4930
4931        case 24:
4932        case 32:
4933                descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors       : 0xff0000;
4934                descr.gMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 1) : 0x00ff00;
4935                descr.bMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 2) : 0x0000ff;
4936                descr.colorMap = 0;
4937                break;
4938
4939        default: break;
4940   }
4941
4942   descr.bits      = bits;
4943   descr.image     = NULL;
4944   descr.palentry  = NULL;
4945   descr.lines     = tmpheight >= 0 ? lines : -lines;
4946   descr.depth     = bmp->bitmap.bmBitsPixel;
4947   descr.drawable  = (Pixmap)bmp->physBitmap;
4948   descr.gc        = BITMAP_GC(bmp);
4949   descr.xSrc      = 0;
4950   descr.ySrc      = 0;
4951   descr.xDest     = 0;
4952   descr.yDest     = height - startscan - lines;
4953   descr.width     = bmp->bitmap.bmWidth;
4954   descr.height    = lines;
4955   descr.useShm    = FALSE;
4956   descr.dibpitch  = ((descr.infoWidth * descr.infoBpp + 31) &~31) / 8;
4957   X11DRV_DIB_Lock(bmp, DIB_Status_GdiMod, FALSE);
4958   result = X11DRV_DIB_SetImageBits( &descr );
4959   X11DRV_DIB_Unlock(bmp, TRUE);
4960
4961   if (descr.colorMap) HeapFree(GetProcessHeap(), 0, descr.colorMap);
4962
4963   GDI_ReleaseObj( hbitmap );
4964   return result;
4965 }
4966
4967 /***********************************************************************
4968  *           GetDIBits   (X11DRV.@)
4969  */
4970 INT X11DRV_GetDIBits( X11DRV_PDEVICE *physDev, HBITMAP hbitmap, UINT startscan, UINT lines,
4971                       LPVOID bits, BITMAPINFO *info, UINT coloruse )
4972 {
4973   X11DRV_DIBSECTION *dib;
4974   X11DRV_DIB_IMAGEBITS_DESCR descr;
4975   PALETTEOBJ * palette;
4976   BITMAPOBJ *bmp;
4977   int height;
4978   DC *dc = physDev->dc;
4979
4980   if (!(palette = (PALETTEOBJ*)GDI_GetObjPtr( dc->hPalette, PALETTE_MAGIC )))
4981       return 0;
4982   if (!(bmp = (BITMAPOBJ *) GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
4983   {
4984       GDI_ReleaseObj( dc->hPalette );
4985       return 0;
4986   }
4987   dib = (X11DRV_DIBSECTION *) bmp->dib;
4988
4989   TRACE("%u scanlines of (%i,%i) -> (%i,%i) starting from %u\n",
4990         lines, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
4991         (int)info->bmiHeader.biWidth, (int)info->bmiHeader.biHeight,
4992         startscan );
4993
4994   if( lines > bmp->bitmap.bmHeight ) lines = bmp->bitmap.bmHeight;
4995
4996   height = info->bmiHeader.biHeight;
4997   if (height < 0) height = -height;
4998   if( lines > height ) lines = height;
4999   /* Top-down images have a negative biHeight, the scanlines of theses images
5000    * were inverted in X11DRV_DIB_GetImageBits_xx
5001    * To prevent this we simply change the sign of lines
5002    * (the number of scan lines to copy).
5003    * Negative lines are correctly handled by X11DRV_DIB_GetImageBits_xx.
5004    */
5005   if( info->bmiHeader.biHeight < 0 && lines > 0) lines = -lines;
5006
5007   if( startscan >= bmp->bitmap.bmHeight )
5008   {
5009       lines = 0;
5010       goto done;
5011   }
5012
5013   if (DIB_GetBitmapInfo( &info->bmiHeader, &descr.infoWidth, &descr.lines,
5014                         &descr.infoBpp, &descr.compression ) == -1)
5015   {
5016       lines = 0;
5017       goto done;
5018   }
5019
5020   switch (descr.infoBpp)
5021   {
5022       case 1:
5023       case 4:
5024       case 8:
5025           descr.rMask= descr.gMask = descr.bMask = 0;
5026           break;
5027       case 15:
5028       case 16:
5029           descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors : 0x7c00;
5030           descr.gMask = (descr.compression == BI_BITFIELDS) ?  *((DWORD *)info->bmiColors + 1) : 0x03e0;
5031           descr.bMask = (descr.compression == BI_BITFIELDS) ?  *((DWORD *)info->bmiColors + 2) : 0x001f;
5032           break;
5033       case 24:
5034       case 32:
5035           descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors : 0xff0000;
5036           descr.gMask = (descr.compression == BI_BITFIELDS) ?  *((DWORD *)info->bmiColors + 1) : 0x00ff00;
5037           descr.bMask = (descr.compression == BI_BITFIELDS) ?  *((DWORD *)info->bmiColors + 2) : 0x0000ff;
5038           break;
5039   }
5040
5041   descr.physDev   = physDev;
5042   descr.palentry  = palette->logpalette.palPalEntry;
5043   descr.bits      = bits;
5044   descr.image     = NULL;
5045   descr.lines     = lines;
5046   descr.depth     = bmp->bitmap.bmBitsPixel;
5047   descr.drawable  = (Pixmap)bmp->physBitmap;
5048   descr.gc        = BITMAP_GC(bmp);
5049   descr.width     = bmp->bitmap.bmWidth;
5050   descr.height    = bmp->bitmap.bmHeight;
5051   descr.colorMap  = info->bmiColors;
5052   descr.xDest     = 0;
5053   descr.yDest     = 0;
5054   descr.xSrc      = 0;
5055
5056   if (descr.lines > 0)
5057   {
5058      descr.ySrc = (descr.height-1) - (startscan + (lines-1));
5059   }
5060   else
5061   {
5062      descr.ySrc = startscan;
5063   }
5064 #ifdef HAVE_LIBXXSHM
5065   descr.useShm = dib ? (dib->shminfo.shmid != -1) : FALSE;
5066 #else
5067   descr.useShm = FALSE;
5068 #endif
5069   descr.dibpitch = dib ? (dib->dibSection.dsBm.bmWidthBytes)
5070                        : (((descr.infoWidth * descr.infoBpp + 31) &~31) / 8);
5071
5072   X11DRV_DIB_Lock(bmp, DIB_Status_GdiMod, FALSE);
5073   X11DRV_DIB_GetImageBits( &descr );
5074   X11DRV_DIB_Unlock(bmp, TRUE);
5075
5076   if(info->bmiHeader.biSizeImage == 0) /* Fill in biSizeImage */
5077       info->bmiHeader.biSizeImage = DIB_GetDIBImageBytes(
5078                                          info->bmiHeader.biWidth,
5079                                          info->bmiHeader.biHeight,
5080                                          info->bmiHeader.biBitCount );
5081
5082   if (descr.compression == BI_BITFIELDS)
5083   {
5084     *(DWORD *)info->bmiColors = descr.rMask;
5085     *((DWORD *)info->bmiColors+1) = descr.gMask;
5086     *((DWORD *)info->bmiColors+2) = descr.bMask;
5087   }
5088   else
5089   {
5090     /* if RLE or JPEG compression were supported,
5091      * this line would be invalid. */
5092     info->bmiHeader.biCompression = 0;
5093   }
5094
5095 done:
5096   GDI_ReleaseObj( dc->hPalette );
5097   GDI_ReleaseObj( hbitmap );
5098   return lines;
5099 }
5100
5101 /***********************************************************************
5102  *           DIB_DoProtectDIBSection
5103  */
5104 static void X11DRV_DIB_DoProtectDIBSection( BITMAPOBJ *bmp, DWORD new_prot )
5105 {
5106     DIBSECTION *dib = bmp->dib;
5107     INT effHeight = dib->dsBm.bmHeight >= 0? dib->dsBm.bmHeight
5108                                              : -dib->dsBm.bmHeight;
5109     /* use the biSizeImage data as the memory size only if we're dealing with a
5110        compressed image where the value is set.  Otherwise, calculate based on
5111        width * height */
5112     INT totalSize = dib->dsBmih.biSizeImage && dib->dsBmih.biCompression != BI_RGB
5113                          ? dib->dsBmih.biSizeImage
5114                          : dib->dsBm.bmWidthBytes * effHeight;
5115     DWORD old_prot;
5116
5117     VirtualProtect(dib->dsBm.bmBits, totalSize, new_prot, &old_prot);
5118     TRACE("Changed protection from %ld to %ld\n", old_prot, new_prot);
5119 }
5120
5121 /***********************************************************************
5122  *           X11DRV_DIB_DoUpdateDIBSection
5123  */
5124 static void X11DRV_DIB_DoCopyDIBSection(BITMAPOBJ *bmp, BOOL toDIB,
5125                                         void *colorMap, int nColorMap,
5126                                         Drawable dest,
5127                                         DWORD xSrc, DWORD ySrc,
5128                                         DWORD xDest, DWORD yDest,
5129                                         DWORD width, DWORD height)
5130 {
5131   X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *) bmp->dib;
5132   X11DRV_DIB_IMAGEBITS_DESCR descr;
5133
5134   if (DIB_GetBitmapInfo( &dib->dibSection.dsBmih, &descr.infoWidth, &descr.lines,
5135                          &descr.infoBpp, &descr.compression ) == -1)
5136     return;
5137
5138   descr.physDev   = NULL;
5139   descr.palentry  = NULL;
5140   descr.image     = dib->image;
5141   descr.colorMap  = colorMap;
5142   descr.nColorMap = nColorMap;
5143   descr.bits      = dib->dibSection.dsBm.bmBits;
5144   descr.depth     = bmp->bitmap.bmBitsPixel;
5145
5146   switch (descr.infoBpp)
5147   {
5148     case 1:
5149     case 4:
5150     case 8:
5151       descr.rMask = descr.gMask = descr.bMask = 0;
5152       break;
5153     case 15:
5154     case 16:
5155       descr.rMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[0] : 0x7c00;
5156       descr.gMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[1] : 0x03e0;
5157       descr.bMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[2] : 0x001f;
5158       break;
5159
5160     case 24:
5161     case 32:
5162       descr.rMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[0] : 0xff0000;
5163       descr.gMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[1] : 0x00ff00;
5164       descr.bMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[2] : 0x0000ff;
5165       break;
5166   }
5167
5168   /* Hack for now */
5169   descr.drawable  = dest;
5170   descr.gc        = BITMAP_GC(bmp);
5171   descr.xSrc      = xSrc;
5172   descr.ySrc      = ySrc;
5173   descr.xDest     = xDest;
5174   descr.yDest     = yDest;
5175   descr.width     = width;
5176   descr.height    = height;
5177 #ifdef HAVE_LIBXXSHM
5178   descr.useShm = (dib->shminfo.shmid != -1);
5179 #else
5180   descr.useShm = FALSE;
5181 #endif
5182   descr.dibpitch = dib->dibSection.dsBm.bmWidthBytes;
5183
5184   if (toDIB)
5185     {
5186       TRACE("Copying from Pixmap to DIB bits\n");
5187       X11DRV_DIB_GetImageBits( &descr );
5188     }
5189   else
5190     {
5191       TRACE("Copying from DIB bits to Pixmap\n");
5192       X11DRV_DIB_SetImageBits( &descr );
5193     }
5194 }
5195
5196 /***********************************************************************
5197  *           X11DRV_DIB_CopyDIBSection
5198  */
5199 void X11DRV_DIB_CopyDIBSection(X11DRV_PDEVICE *physDevSrc, X11DRV_PDEVICE *physDevDst,
5200                                DWORD xSrc, DWORD ySrc, DWORD xDest, DWORD yDest,
5201                                DWORD width, DWORD height)
5202 {
5203   BITMAPOBJ *bmp;
5204   DC *dcSrc = physDevSrc->dc;
5205   DC *dcDst = physDevDst->dc;
5206   int nColorMap = 0, *colorMap = NULL, aColorMap = FALSE;
5207
5208   TRACE("(%p,%p,%ld,%ld,%ld,%ld,%ld,%ld)\n", dcSrc, dcDst,
5209     xSrc, ySrc, xDest, yDest, width, height);
5210   /* this function is meant as an optimization for BitBlt,
5211    * not to be called otherwise */
5212   if (GetObjectType( physDevSrc->hdc ) != OBJ_MEMDC) {
5213     ERR("called for non-memory source DC!?\n");
5214     return;
5215   }
5216
5217   bmp = (BITMAPOBJ *)GDI_GetObjPtr( dcSrc->hBitmap, BITMAP_MAGIC );
5218   if (!(bmp && bmp->dib)) {
5219     ERR("called for non-DIBSection!?\n");
5220     GDI_ReleaseObj( dcSrc->hBitmap );
5221     return;
5222   }
5223   /* while BitBlt should already have made sure we only get
5224    * positive values, we should check for oversize values */
5225   if ((xSrc < bmp->bitmap.bmWidth) &&
5226       (ySrc < bmp->bitmap.bmHeight)) {
5227     if (xSrc + width > bmp->bitmap.bmWidth)
5228       width = bmp->bitmap.bmWidth - xSrc;
5229     if (ySrc + height > bmp->bitmap.bmHeight)
5230       height = bmp->bitmap.bmHeight - ySrc;
5231     /* if the source bitmap is 8bpp or less, we're supposed to use the
5232      * DC's palette for color conversion (not the DIB color table) */
5233     if (bmp->dib->dsBm.bmBitsPixel <= 8) {
5234       X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *) bmp->dib;
5235       if ((!dcSrc->hPalette) ||
5236           (dcSrc->hPalette == GetStockObject(DEFAULT_PALETTE))) {
5237         /* HACK: no palette has been set in the source DC,
5238          * use the DIB colormap instead - this is necessary in some
5239          * cases since we need to do depth conversion in some places
5240          * where real Windows can just copy data straight over */
5241         colorMap = dib->colorMap;
5242         nColorMap = dib->nColorMap;
5243       } else {
5244         colorMap = X11DRV_DIB_BuildColorMap( physDevSrc, (WORD)-1,
5245                                              bmp->dib->dsBm.bmBitsPixel,
5246                                              (BITMAPINFO*)&(bmp->dib->dsBmih),
5247                                              &nColorMap );
5248         if (colorMap) aColorMap = TRUE;
5249       }
5250     }
5251     /* perform the copy */
5252     X11DRV_DIB_DoCopyDIBSection(bmp, FALSE, colorMap, nColorMap,
5253                                 physDevDst->drawable, xSrc, ySrc,
5254                                 physDevDst->org.x + xDest, physDevDst->org.y + yDest,
5255                                 width, height);
5256     /* free color mapping */
5257     if (aColorMap)
5258       HeapFree(GetProcessHeap(), 0, colorMap);
5259   }
5260   GDI_ReleaseObj( dcSrc->hBitmap );
5261 }
5262
5263 /***********************************************************************
5264  *           X11DRV_DIB_DoUpdateDIBSection
5265  */
5266 static void X11DRV_DIB_DoUpdateDIBSection(BITMAPOBJ *bmp, BOOL toDIB)
5267 {
5268   X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *) bmp->dib;
5269   X11DRV_DIB_DoCopyDIBSection(bmp, toDIB, dib->colorMap, dib->nColorMap,
5270                               (Drawable)bmp->physBitmap, 0, 0, 0, 0,
5271                               bmp->bitmap.bmWidth, bmp->bitmap.bmHeight);
5272 }
5273
5274 /***********************************************************************
5275  *           X11DRV_DIB_FaultHandler
5276  */
5277 static BOOL X11DRV_DIB_FaultHandler( LPVOID res, LPCVOID addr )
5278 {
5279   BITMAPOBJ *bmp;
5280   INT state;
5281
5282   bmp = (BITMAPOBJ *)GDI_GetObjPtr( (HBITMAP)res, BITMAP_MAGIC );
5283   if (!bmp) return FALSE;
5284
5285   state = X11DRV_DIB_Lock(bmp, DIB_Status_None, FALSE);
5286   if (state != DIB_Status_InSync) {
5287     /* no way to tell whether app needs read or write yet,
5288      * try read first */
5289     X11DRV_DIB_Coerce(bmp, DIB_Status_InSync, FALSE);
5290   } else {
5291     /* hm, apparently the app must have write access */
5292     X11DRV_DIB_Coerce(bmp, DIB_Status_AppMod, FALSE);
5293   }
5294   X11DRV_DIB_Unlock(bmp, TRUE);
5295
5296   GDI_ReleaseObj( (HBITMAP)res );
5297   return TRUE;
5298 }
5299
5300 /***********************************************************************
5301  *           X11DRV_DIB_Coerce
5302  */
5303 INT X11DRV_DIB_Coerce(BITMAPOBJ *bmp, INT req, BOOL lossy)
5304 {
5305   X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *) bmp->dib;
5306   INT ret = DIB_Status_None;
5307
5308   if (dib) {
5309     EnterCriticalSection(&(dib->lock));
5310     ret = dib->status;
5311     switch (req) {
5312     case DIB_Status_GdiMod:
5313       /* GDI access - request to draw on pixmap */
5314       switch (dib->status)
5315       {
5316         default:
5317         case DIB_Status_None:
5318           dib->p_status = DIB_Status_GdiMod;
5319           X11DRV_DIB_DoUpdateDIBSection( bmp, FALSE );
5320           break;
5321
5322         case DIB_Status_GdiMod:
5323           TRACE("GdiMod requested in status GdiMod\n" );
5324           break;
5325
5326         case DIB_Status_InSync:
5327           TRACE("GdiMod requested in status InSync\n" );
5328           X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_NOACCESS );
5329           dib->status = DIB_Status_GdiMod;
5330           dib->p_status = DIB_Status_InSync;
5331           break;
5332
5333         case DIB_Status_AuxMod:
5334           TRACE("GdiMod requested in status AuxMod\n" );
5335           if (lossy) dib->status = DIB_Status_GdiMod;
5336           else (*dib->copy_aux)(dib->aux_ctx, DIB_Status_GdiMod);
5337           dib->p_status = DIB_Status_AuxMod;
5338           if (dib->status != DIB_Status_AppMod) {
5339             X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_NOACCESS );
5340             break;
5341           }
5342           /* fall through if copy_aux() had to change to AppMod state */
5343
5344         case DIB_Status_AppMod:
5345           TRACE("GdiMod requested in status AppMod\n" );
5346           if (!lossy) {
5347             /* make it readonly to avoid app changing data while we copy */
5348             X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READONLY );
5349             X11DRV_DIB_DoUpdateDIBSection( bmp, FALSE );
5350           }
5351           X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_NOACCESS );
5352           dib->p_status = DIB_Status_AppMod;
5353           dib->status = DIB_Status_GdiMod;
5354           break;
5355       }
5356       break;
5357
5358     case DIB_Status_InSync:
5359       /* App access - request access to read DIB surface */
5360       /* (typically called from signal handler) */
5361       switch (dib->status)
5362       {
5363         default:
5364         case DIB_Status_None:
5365           /* shouldn't happen from signal handler */
5366           break;
5367
5368         case DIB_Status_AuxMod:
5369           TRACE("InSync requested in status AuxMod\n" );
5370           if (lossy) dib->status = DIB_Status_InSync;
5371           else {
5372             X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READWRITE );
5373             (*dib->copy_aux)(dib->aux_ctx, DIB_Status_InSync);
5374           }
5375           if (dib->status != DIB_Status_GdiMod) {
5376             X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READONLY );
5377             break;
5378           }
5379           /* fall through if copy_aux() had to change to GdiMod state */
5380
5381         case DIB_Status_GdiMod:
5382           TRACE("InSync requested in status GdiMod\n" );
5383           if (!lossy) {
5384             X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READWRITE );
5385             X11DRV_DIB_DoUpdateDIBSection( bmp, TRUE );
5386           }
5387           X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READONLY );
5388           dib->status = DIB_Status_InSync;
5389           break;
5390
5391         case DIB_Status_InSync:
5392           TRACE("InSync requested in status InSync\n" );
5393           /* shouldn't happen from signal handler */
5394           break;
5395
5396         case DIB_Status_AppMod:
5397           TRACE("InSync requested in status AppMod\n" );
5398           /* no reason to do anything here, and this
5399            * shouldn't happen from signal handler */
5400           break;
5401       }
5402       break;
5403
5404     case DIB_Status_AppMod:
5405       /* App access - request access to write DIB surface */
5406       /* (typically called from signal handler) */
5407       switch (dib->status)
5408       {
5409         default:
5410         case DIB_Status_None:
5411           /* shouldn't happen from signal handler */
5412           break;
5413
5414         case DIB_Status_AuxMod:
5415           TRACE("AppMod requested in status AuxMod\n" );
5416           X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READWRITE );
5417           if (lossy) dib->status = DIB_Status_AppMod;
5418           else (*dib->copy_aux)(dib->aux_ctx, DIB_Status_AppMod);
5419           if (dib->status != DIB_Status_GdiMod)
5420             break;
5421           /* fall through if copy_aux() had to change to GdiMod state */
5422
5423         case DIB_Status_GdiMod:
5424           TRACE("AppMod requested in status GdiMod\n" );
5425           X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READWRITE );
5426           if (!lossy) X11DRV_DIB_DoUpdateDIBSection( bmp, TRUE );
5427           dib->status = DIB_Status_AppMod;
5428           break;
5429
5430         case DIB_Status_InSync:
5431           TRACE("AppMod requested in status InSync\n" );
5432           X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READWRITE );
5433           dib->status = DIB_Status_AppMod;
5434           break;
5435
5436         case DIB_Status_AppMod:
5437           TRACE("AppMod requested in status AppMod\n" );
5438           /* shouldn't happen from signal handler */
5439           break;
5440       }
5441       break;
5442
5443     case DIB_Status_AuxMod:
5444       if (dib->status == DIB_Status_None) {
5445         dib->p_status = req;
5446       } else {
5447         if (dib->status != DIB_Status_AuxMod)
5448           dib->p_status = dib->status;
5449         dib->status = DIB_Status_AuxMod;
5450       }
5451       break;
5452       /* it is up to the caller to do the copy/conversion, probably
5453        * using the return value to decide where to copy from */
5454     }
5455     LeaveCriticalSection(&(dib->lock));
5456   }
5457   return ret;
5458 }
5459
5460 /***********************************************************************
5461  *           X11DRV_DIB_Lock
5462  */
5463 INT X11DRV_DIB_Lock(BITMAPOBJ *bmp, INT req, BOOL lossy)
5464 {
5465   X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *) bmp->dib;
5466   INT ret = DIB_Status_None;
5467
5468   if (dib) {
5469     TRACE("Locking %p from thread %04lx\n", bmp, GetCurrentThreadId());
5470     EnterCriticalSection(&(dib->lock));
5471     ret = dib->status;
5472     if (req != DIB_Status_None)
5473       X11DRV_DIB_Coerce(bmp, req, lossy);
5474   }
5475   return ret;
5476 }
5477
5478 /***********************************************************************
5479  *           X11DRV_DIB_Unlock
5480  */
5481 void X11DRV_DIB_Unlock(BITMAPOBJ *bmp, BOOL commit)
5482 {
5483   X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *) bmp->dib;
5484
5485   if (dib) {
5486     switch (dib->status)
5487     {
5488       default:
5489       case DIB_Status_None:
5490         /* in case anyone is wondering, this is the "signal handler doesn't
5491          * work" case, where we always have to be ready for app access */
5492         if (commit) {
5493           switch (dib->p_status)
5494           {
5495             case DIB_Status_AuxMod:
5496               TRACE("Unlocking and syncing from AuxMod\n" );
5497               (*dib->copy_aux)(dib->aux_ctx, DIB_Status_AppMod);
5498               if (dib->status != DIB_Status_None) {
5499                 dib->p_status = dib->status;
5500                 dib->status = DIB_Status_None;
5501               }
5502               if (dib->p_status != DIB_Status_GdiMod)
5503                 break;
5504               /* fall through if copy_aux() had to change to GdiMod state */
5505
5506             case DIB_Status_GdiMod:
5507               TRACE("Unlocking and syncing from GdiMod\n" );
5508               X11DRV_DIB_DoUpdateDIBSection( bmp, TRUE );
5509               break;
5510
5511             default:
5512               TRACE("Unlocking without needing to sync\n" );
5513               break;
5514           }
5515         }
5516         else TRACE("Unlocking with no changes\n");
5517         dib->p_status = DIB_Status_None;
5518         break;
5519
5520       case DIB_Status_GdiMod:
5521         TRACE("Unlocking in status GdiMod\n" );
5522         /* DIB was protected in Coerce */
5523         if (!commit) {
5524           /* no commit, revert to InSync if applicable */
5525           if ((dib->p_status == DIB_Status_InSync) ||
5526               (dib->p_status == DIB_Status_AppMod)) {
5527             X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READONLY );
5528             dib->status = DIB_Status_InSync;
5529           }
5530         }
5531         break;
5532
5533       case DIB_Status_InSync:
5534         TRACE("Unlocking in status InSync\n" );
5535         /* DIB was already protected in Coerce */
5536         break;
5537
5538       case DIB_Status_AppMod:
5539         TRACE("Unlocking in status AppMod\n" );
5540         /* DIB was already protected in Coerce */
5541         /* this case is ordinary only called from the signal handler,
5542          * so we don't bother to check for !commit */
5543         break;
5544
5545       case DIB_Status_AuxMod:
5546         TRACE("Unlocking in status AuxMod\n" );
5547         if (commit) {
5548           /* DIB may need protection now */
5549           if ((dib->p_status == DIB_Status_InSync) ||
5550               (dib->p_status == DIB_Status_AppMod))
5551             X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_NOACCESS );
5552         } else {
5553           /* no commit, revert to previous state */
5554           if (dib->p_status != DIB_Status_None)
5555             dib->status = dib->p_status;
5556           /* no protections changed */
5557         }
5558         dib->p_status = DIB_Status_None;
5559         break;
5560     }
5561     LeaveCriticalSection(&(dib->lock));
5562     TRACE("Unlocked %p\n", bmp);
5563   }
5564 }
5565
5566 /***********************************************************************
5567  *           X11DRV_CoerceDIBSection2
5568  */
5569 INT X11DRV_CoerceDIBSection2(HBITMAP hBmp, INT req, BOOL lossy)
5570 {
5571   BITMAPOBJ *bmp;
5572   INT ret;
5573
5574   bmp = (BITMAPOBJ *)GDI_GetObjPtr( hBmp, BITMAP_MAGIC );
5575   if (!bmp) return DIB_Status_None;
5576   ret = X11DRV_DIB_Coerce(bmp, req, lossy);
5577   GDI_ReleaseObj( hBmp );
5578   return ret;
5579 }
5580
5581 /***********************************************************************
5582  *           X11DRV_LockDIBSection2
5583  */
5584 INT X11DRV_LockDIBSection2(HBITMAP hBmp, INT req, BOOL lossy)
5585 {
5586   BITMAPOBJ *bmp;
5587   INT ret;
5588
5589   bmp = (BITMAPOBJ *)GDI_GetObjPtr( hBmp, BITMAP_MAGIC );
5590   if (!bmp) return DIB_Status_None;
5591   ret = X11DRV_DIB_Lock(bmp, req, lossy);
5592   GDI_ReleaseObj( hBmp );
5593   return ret;
5594 }
5595
5596 /***********************************************************************
5597  *           X11DRV_UnlockDIBSection2
5598  */
5599 void X11DRV_UnlockDIBSection2(HBITMAP hBmp, BOOL commit)
5600 {
5601   BITMAPOBJ *bmp;
5602
5603   bmp = (BITMAPOBJ *)GDI_GetObjPtr( hBmp, BITMAP_MAGIC );
5604   if (!bmp) return;
5605   X11DRV_DIB_Unlock(bmp, commit);
5606   GDI_ReleaseObj( hBmp );
5607 }
5608
5609 /***********************************************************************
5610  *           X11DRV_CoerceDIBSection
5611  */
5612 INT X11DRV_CoerceDIBSection(X11DRV_PDEVICE *physDev, INT req, BOOL lossy)
5613 {
5614   if (!physDev) return DIB_Status_None;
5615   return X11DRV_CoerceDIBSection2( physDev->dc->hBitmap, req, lossy );
5616 }
5617
5618 /***********************************************************************
5619  *           X11DRV_LockDIBSection
5620  */
5621 INT X11DRV_LockDIBSection(X11DRV_PDEVICE *physDev, INT req, BOOL lossy)
5622 {
5623   if (!physDev) return DIB_Status_None;
5624   if (GetObjectType( physDev->hdc ) != OBJ_MEMDC) return DIB_Status_None;
5625
5626   return X11DRV_LockDIBSection2( physDev->dc->hBitmap, req, lossy );
5627 }
5628
5629 /***********************************************************************
5630  *           X11DRV_UnlockDIBSection
5631  */
5632 void X11DRV_UnlockDIBSection(X11DRV_PDEVICE *physDev, BOOL commit)
5633 {
5634   if (!physDev) return;
5635   if (GetObjectType( physDev->hdc ) != OBJ_MEMDC) return;
5636
5637   X11DRV_UnlockDIBSection2( physDev->dc->hBitmap, commit );
5638 }
5639
5640
5641 #ifdef HAVE_LIBXXSHM
5642 /***********************************************************************
5643  *           X11DRV_XShmErrorHandler
5644  *
5645  */
5646 static int XShmErrorHandler( Display *dpy, XErrorEvent *event, void *arg )
5647 {
5648     return 1;  /* FIXME: should check event contents */
5649 }
5650
5651 /***********************************************************************
5652  *           X11DRV_XShmCreateImage
5653  *
5654  */
5655 static XImage *X11DRV_XShmCreateImage( int width, int height, int bpp,
5656                                        XShmSegmentInfo* shminfo)
5657 {
5658     XImage *image;
5659
5660     image = XShmCreateImage(gdi_display, visual, bpp, ZPixmap, NULL, shminfo, width, height);
5661     if (image)
5662     {
5663         shminfo->shmid = shmget(IPC_PRIVATE, image->bytes_per_line * height,
5664                                   IPC_CREAT|0700);
5665         if( shminfo->shmid != -1 )
5666         {
5667             shminfo->shmaddr = image->data = shmat(shminfo->shmid, 0, 0);
5668             if( shminfo->shmaddr != (char*)-1 )
5669             {
5670                 BOOL ok;
5671
5672                 shminfo->readOnly = FALSE;
5673                 X11DRV_expect_error( gdi_display, XShmErrorHandler, NULL );
5674                 ok = (XShmAttach( gdi_display, shminfo ) != 0);
5675                 if (X11DRV_check_error()) ok = FALSE;
5676                 if (ok)
5677                 {
5678                     shmctl(shminfo->shmid, IPC_RMID, 0);
5679                     return image; /* Success! */
5680                 }
5681                 /* An error occured */
5682                 shmdt(shminfo->shmaddr);
5683             }
5684             shmctl(shminfo->shmid, IPC_RMID, 0);
5685         }
5686         XFlush(gdi_display);
5687         XDestroyImage(image);
5688         image = NULL;
5689     }
5690     return image;
5691 }
5692 #endif /* HAVE_LIBXXSHM */
5693
5694
5695 /***********************************************************************
5696  *           X11DRV_DIB_CreateDIBSection
5697  */
5698 HBITMAP X11DRV_DIB_CreateDIBSection(
5699   X11DRV_PDEVICE *physDev, BITMAPINFO *bmi, UINT usage,
5700   LPVOID *bits, HANDLE section,
5701   DWORD offset, DWORD ovr_pitch)
5702 {
5703   HBITMAP res = 0;
5704   BITMAPOBJ *bmp = NULL;
5705   X11DRV_DIBSECTION *dib = NULL;
5706   int *colorMap = NULL;
5707   int nColorMap;
5708
5709   /* Fill BITMAP32 structure with DIB data */
5710   BITMAPINFOHEADER *bi = &bmi->bmiHeader;
5711   INT effHeight, totalSize;
5712   BITMAP bm;
5713   LPVOID mapBits = NULL;
5714
5715   TRACE("format (%ld,%ld), planes %d, bpp %d, size %ld, colors %ld (%s)\n",
5716         bi->biWidth, bi->biHeight, bi->biPlanes, bi->biBitCount,
5717         bi->biSizeImage, bi->biClrUsed, usage == DIB_PAL_COLORS? "PAL" : "RGB");
5718
5719   effHeight = bi->biHeight >= 0 ? bi->biHeight : -bi->biHeight;
5720   bm.bmType = 0;
5721   bm.bmWidth = bi->biWidth;
5722   bm.bmHeight = effHeight;
5723   bm.bmWidthBytes = ovr_pitch ? ovr_pitch
5724                               : DIB_GetDIBWidthBytes(bm.bmWidth, bi->biBitCount);
5725   bm.bmPlanes = bi->biPlanes;
5726   bm.bmBitsPixel = bi->biBitCount;
5727   bm.bmBits = NULL;
5728
5729   /* Get storage location for DIB bits.  Only use biSizeImage if it's valid and
5730      we're dealing with a compressed bitmap.  Otherwise, use width * height. */
5731   totalSize = bi->biSizeImage && bi->biCompression != BI_RGB
5732     ? bi->biSizeImage : bm.bmWidthBytes * effHeight;
5733
5734   if (section)
5735   {
5736       SYSTEM_INFO SystemInfo;
5737       DWORD mapOffset;
5738       INT mapSize;
5739
5740       GetSystemInfo( &SystemInfo );
5741       mapOffset = offset - (offset % SystemInfo.dwAllocationGranularity);
5742       mapSize = totalSize + (offset - mapOffset);
5743       mapBits = MapViewOfFile( section,
5744                                FILE_MAP_ALL_ACCESS,
5745                                0L,
5746                                mapOffset,
5747                                mapSize );
5748       bm.bmBits = (char *)mapBits + (offset - mapOffset);
5749   }
5750   else if (ovr_pitch && offset)
5751     bm.bmBits = (LPVOID) offset;
5752   else {
5753     offset = 0;
5754     bm.bmBits = VirtualAlloc(NULL, totalSize,
5755                              MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
5756   }
5757
5758   /* Create Color Map */
5759   if (bm.bmBits && bm.bmBitsPixel <= 8)
5760       colorMap = X11DRV_DIB_BuildColorMap( usage == DIB_PAL_COLORS? physDev : NULL,
5761                                            usage, bm.bmBitsPixel, bmi, &nColorMap );
5762
5763   /* Allocate Memory for DIB and fill structure */
5764   if (bm.bmBits)
5765     dib = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(X11DRV_DIBSECTION));
5766   if (dib)
5767     {
5768       dib->dibSection.dsBm = bm;
5769       dib->dibSection.dsBmih = *bi;
5770       dib->dibSection.dsBmih.biSizeImage = totalSize;
5771
5772       /* Set dsBitfields values */
5773        if ( usage == DIB_PAL_COLORS || bi->biBitCount <= 8)
5774        {
5775            dib->dibSection.dsBitfields[0] = dib->dibSection.dsBitfields[1] = dib->dibSection.dsBitfields[2] = 0;
5776        }
5777        else switch( bi->biBitCount )
5778        {
5779            case 15:
5780            case 16:
5781                dib->dibSection.dsBitfields[0] = (bi->biCompression == BI_BITFIELDS) ? *(DWORD *)bmi->bmiColors : 0x7c00;
5782                dib->dibSection.dsBitfields[1] = (bi->biCompression == BI_BITFIELDS) ? *((DWORD *)bmi->bmiColors + 1) : 0x03e0;
5783                dib->dibSection.dsBitfields[2] = (bi->biCompression == BI_BITFIELDS) ? *((DWORD *)bmi->bmiColors + 2) : 0x001f;
5784                break;
5785
5786            case 24:
5787            case 32:
5788                dib->dibSection.dsBitfields[0] = (bi->biCompression == BI_BITFIELDS) ? *(DWORD *)bmi->bmiColors       : 0xff0000;
5789                dib->dibSection.dsBitfields[1] = (bi->biCompression == BI_BITFIELDS) ? *((DWORD *)bmi->bmiColors + 1) : 0x00ff00;
5790                dib->dibSection.dsBitfields[2] = (bi->biCompression == BI_BITFIELDS) ? *((DWORD *)bmi->bmiColors + 2) : 0x0000ff;
5791                break;
5792        }
5793       dib->dibSection.dshSection = section;
5794       dib->dibSection.dsOffset = offset;
5795
5796       dib->status    = DIB_Status_None;
5797       dib->nColorMap = nColorMap;
5798       dib->colorMap  = colorMap;
5799     }
5800
5801   /* Create Device Dependent Bitmap and add DIB pointer */
5802   if (dib)
5803     {
5804       res = CreateDIBitmap(physDev->hdc, bi, 0, NULL, bmi, usage);
5805       if (res)
5806         {
5807           bmp = (BITMAPOBJ *) GDI_GetObjPtr(res, BITMAP_MAGIC);
5808           if (bmp) bmp->dib = (DIBSECTION *) dib;
5809         }
5810     }
5811
5812   /* Create XImage */
5813   if (dib && bmp)
5814   {
5815       wine_tsx11_lock();
5816 #ifdef HAVE_LIBXXSHM
5817       if (XShmQueryExtension(gdi_display) &&
5818           (dib->image = X11DRV_XShmCreateImage( bm.bmWidth, effHeight,
5819                                                 bmp->bitmap.bmBitsPixel, &dib->shminfo )) )
5820       {
5821         ; /* Created Image */
5822       } else {
5823           dib->image = X11DRV_DIB_CreateXImage( bm.bmWidth, effHeight, bmp->bitmap.bmBitsPixel );
5824           dib->shminfo.shmid = -1;
5825       }
5826 #else
5827       dib->image = X11DRV_DIB_CreateXImage( bm.bmWidth, effHeight, bmp->bitmap.bmBitsPixel );
5828 #endif
5829       wine_tsx11_unlock();
5830   }
5831
5832   /* Clean up in case of errors */
5833   if (!res || !bmp || !dib || !bm.bmBits || (bm.bmBitsPixel <= 8 && !colorMap))
5834     {
5835       TRACE("got an error res=%p, bmp=%p, dib=%p, bm.bmBits=%p\n",
5836             res, bmp, dib, bm.bmBits);
5837       if (bm.bmBits)
5838         {
5839           if (section)
5840             UnmapViewOfFile(mapBits), bm.bmBits = NULL;
5841           else if (!offset)
5842             VirtualFree(bm.bmBits, 0L, MEM_RELEASE), bm.bmBits = NULL;
5843         }
5844
5845       if (dib && dib->image) { XDestroyImage(dib->image); dib->image = NULL; }
5846       if (colorMap) { HeapFree(GetProcessHeap(), 0, colorMap); colorMap = NULL; }
5847       if (dib) { HeapFree(GetProcessHeap(), 0, dib); dib = NULL; }
5848       if (bmp) { GDI_ReleaseObj(res); bmp = NULL; }
5849       if (res) { DeleteObject(res); res = 0; }
5850     }
5851   else if (bm.bmBits)
5852     {
5853       /* Install fault handler, if possible */
5854       InitializeCriticalSection(&(dib->lock));
5855       if (VIRTUAL_SetFaultHandler(bm.bmBits, X11DRV_DIB_FaultHandler, (LPVOID)res))
5856         {
5857           X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READWRITE );
5858           if (dib) dib->status = DIB_Status_AppMod;
5859         }
5860     }
5861
5862   /* Return BITMAP handle and storage location */
5863   if (bmp) GDI_ReleaseObj(res);
5864   if (bm.bmBits && bits) *bits = bm.bmBits;
5865   return res;
5866 }
5867
5868 /***********************************************************************
5869  *           X11DRV_DIB_DeleteDIBSection
5870  */
5871 void X11DRV_DIB_DeleteDIBSection(BITMAPOBJ *bmp)
5872 {
5873   X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *) bmp->dib;
5874
5875   if (dib->image)
5876   {
5877       wine_tsx11_lock();
5878 #ifdef HAVE_LIBXXSHM
5879       if (dib->shminfo.shmid != -1)
5880       {
5881           XShmDetach (gdi_display, &(dib->shminfo));
5882           XDestroyImage (dib->image);
5883           shmdt (dib->shminfo.shmaddr);
5884           dib->shminfo.shmid = -1;
5885       }
5886       else
5887 #endif
5888           XDestroyImage( dib->image );
5889       wine_tsx11_unlock();
5890   }
5891
5892   if (dib->colorMap)
5893     HeapFree(GetProcessHeap(), 0, dib->colorMap);
5894
5895   DeleteCriticalSection(&(dib->lock));
5896 }
5897
5898 /***********************************************************************
5899  *           SetDIBColorTable   (X11DRV.@)
5900  */
5901 UINT X11DRV_SetDIBColorTable( X11DRV_PDEVICE *physDev, UINT start, UINT count, const RGBQUAD *colors )
5902 {
5903     BITMAPOBJ * bmp;
5904     X11DRV_DIBSECTION *dib;
5905     UINT ret = 0;
5906
5907     if (!(bmp = (BITMAPOBJ*)GDI_GetObjPtr( physDev->dc->hBitmap, BITMAP_MAGIC ))) return 0;
5908     dib = (X11DRV_DIBSECTION *) bmp->dib;
5909
5910     if (dib && dib->colorMap) {
5911         UINT end = count + start;
5912         if (end > dib->nColorMap) end = dib->nColorMap;
5913         /*
5914          * Changing color table might change the mapping between
5915          * DIB colors and X11 colors and thus alter the visible state
5916          * of the bitmap object.
5917          */
5918         X11DRV_DIB_Lock(bmp, DIB_Status_AppMod, FALSE);
5919         X11DRV_DIB_GenColorMap( physDev, dib->colorMap, DIB_RGB_COLORS,
5920                                 dib->dibSection.dsBm.bmBitsPixel,
5921                                 TRUE, colors, start, end );
5922         X11DRV_DIB_Unlock(bmp, TRUE);
5923         ret = end - start;
5924     }
5925     GDI_ReleaseObj( physDev->dc->hBitmap );
5926     return ret;
5927 }
5928
5929 /***********************************************************************
5930  *           GetDIBColorTable   (X11DRV.@)
5931  */
5932 UINT X11DRV_GetDIBColorTable( X11DRV_PDEVICE *physDev, UINT start, UINT count, RGBQUAD *colors )
5933 {
5934     BITMAPOBJ * bmp;
5935     X11DRV_DIBSECTION *dib;
5936     UINT ret = 0;
5937
5938     if (!(bmp = (BITMAPOBJ*)GDI_GetObjPtr( physDev->dc->hBitmap, BITMAP_MAGIC ))) return 0;
5939     dib = (X11DRV_DIBSECTION *) bmp->dib;
5940
5941     if (dib && dib->colorMap) {
5942         UINT i, end = count + start;
5943         if (end > dib->nColorMap) end = dib->nColorMap;
5944         for (i = start; i < end; i++,colors++) {
5945             COLORREF col = X11DRV_PALETTE_ToLogical( dib->colorMap[i] );
5946             colors->rgbBlue  = GetBValue(col);
5947             colors->rgbGreen = GetGValue(col);
5948             colors->rgbRed   = GetRValue(col);
5949             colors->rgbReserved = 0;
5950         }
5951         ret = end-start;
5952     }
5953     GDI_ReleaseObj( physDev->dc->hBitmap );
5954     return ret;
5955 }
5956
5957
5958 /**************************************************************************
5959  *              X11DRV_DIB_CreateDIBFromPixmap
5960  *
5961  *  Allocates a packed DIB and copies the Pixmap data into it.
5962  *  If bDeletePixmap is TRUE, the Pixmap passed in is deleted after the conversion.
5963  */
5964 HGLOBAL X11DRV_DIB_CreateDIBFromPixmap(Pixmap pixmap, HDC hdc, BOOL bDeletePixmap)
5965 {
5966     HBITMAP hBmp = 0;
5967     BITMAPOBJ *pBmp = NULL;
5968     HGLOBAL hPackedDIB = 0;
5969
5970     /* Allocates an HBITMAP which references the Pixmap passed to us */
5971     hBmp = X11DRV_BITMAP_CreateBitmapHeaderFromPixmap(pixmap);
5972     if (!hBmp)
5973     {
5974         TRACE("\tCould not create bitmap header for Pixmap\n");
5975         goto END;
5976     }
5977
5978     /*
5979      * Create a packed DIB from the Pixmap wrapper bitmap created above.
5980      * A packed DIB contains a BITMAPINFO structure followed immediately by
5981      * an optional color palette and the pixel data.
5982      */
5983     hPackedDIB = DIB_CreateDIBFromBitmap(hdc, hBmp);
5984
5985     /* Get a pointer to the BITMAPOBJ structure */
5986     pBmp = (BITMAPOBJ *)GDI_GetObjPtr( hBmp, BITMAP_MAGIC );
5987
5988     /* We can now get rid of the HBITMAP wrapper we created earlier.
5989      * Note: Simply calling DeleteObject will free the embedded Pixmap as well.
5990      */
5991     if (!bDeletePixmap)
5992     {
5993         /* Clear the physBitmap to prevent the Pixmap from being deleted by DeleteObject */
5994         pBmp->physBitmap = NULL;
5995         pBmp->funcs = NULL;
5996     }
5997     GDI_ReleaseObj( hBmp );
5998     DeleteObject(hBmp);
5999
6000 END:
6001     TRACE("\tReturning packed DIB %p\n", hPackedDIB);
6002     return hPackedDIB;
6003 }
6004
6005
6006 /**************************************************************************
6007  *                 X11DRV_DIB_CreatePixmapFromDIB
6008  *
6009  *    Creates a Pixmap from a packed DIB
6010  */
6011 Pixmap X11DRV_DIB_CreatePixmapFromDIB( HGLOBAL hPackedDIB, HDC hdc )
6012 {
6013     Pixmap pixmap = None;
6014     HBITMAP hBmp = 0;
6015     BITMAPOBJ *pBmp = NULL;
6016     LPBYTE pPackedDIB = NULL;
6017     LPBITMAPINFO pbmi = NULL;
6018     LPBITMAPINFOHEADER pbmiHeader = NULL;
6019     LPBYTE pbits = NULL;
6020
6021     /* Get a pointer to the packed DIB's data  */
6022     pPackedDIB = (LPBYTE)GlobalLock(hPackedDIB);
6023     pbmiHeader = (LPBITMAPINFOHEADER)pPackedDIB;
6024     pbmi = (LPBITMAPINFO)pPackedDIB;
6025     pbits = (LPBYTE)(pPackedDIB
6026                      + DIB_BitmapInfoSize( (LPBITMAPINFO)pbmiHeader, DIB_RGB_COLORS ));
6027
6028     /* Create a DDB from the DIB */
6029
6030     hBmp = CreateDIBitmap(hdc,
6031                           pbmiHeader,
6032                           CBM_INIT,
6033                           (LPVOID)pbits,
6034                           pbmi,
6035                           DIB_RGB_COLORS);
6036
6037     GlobalUnlock(hPackedDIB);
6038
6039     TRACE("CreateDIBitmap returned %p\n", hBmp);
6040
6041     /* Retrieve the internal Pixmap from the DDB */
6042
6043     pBmp = (BITMAPOBJ *) GDI_GetObjPtr( hBmp, BITMAP_MAGIC );
6044
6045     pixmap = (Pixmap)pBmp->physBitmap;
6046     /* clear the physBitmap so that we can steal its pixmap */
6047     pBmp->physBitmap = NULL;
6048     pBmp->funcs = NULL;
6049
6050     /* Delete the DDB we created earlier now that we have stolen its pixmap */
6051     GDI_ReleaseObj( hBmp );
6052     DeleteObject(hBmp);
6053
6054     TRACE("\tReturning Pixmap %ld\n", pixmap);
6055     return pixmap;
6056 }