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
   7 #include "config.h"
   8
   9 #include "ts_xlib.h"
  10 #include "ts_xutil.h"
  11 #ifdef HAVE_LIBXXSHM
  12 # include "ts_xshm.h"
  13 # ifdef HAVE_SYS_SHM_H
  14 #  include <sys/shm.h>
  15 # endif
  16 # ifdef HAVE_SYS_IPC_H
  17 #  include <sys/ipc.h>
  18 # endif
  19 #endif /* defined(HAVE_LIBXXSHM) */
  20
  21 #include <stdlib.h>
  22 #include "windef.h"
  23 #include "bitmap.h"
  24 #include "x11drv.h"
  25 #include "debugtools.h"
  26 #include "dc.h"
  27 #include "color.h"
  28 #include "callback.h"
  29 #include "selectors.h"
  30 #include "global.h"
  31
  32 DEFAULT_DEBUG_CHANNEL(bitmap)
  33 DECLARE_DEBUG_CHANNEL(x11drv)
  34
  35 static int bitmapDepthTable[] = { 8, 1, 32, 16, 24, 15, 4, 0 };
  36 static int ximageDepthTable[] = { 0, 0, 0,  0,  0,  0,  0 };
  37
  38 static int XShmErrorFlag = 0;
  39
  40 /***********************************************************************
  41  *           X11DRV_DIB_Init
  42  */
  43 BOOL X11DRV_DIB_Init(void)
  44 {
  45     int         i;
  46     XImage*     testimage;
  47
  48     for( i = 0; bitmapDepthTable[i]; i++ )
  49     {
  50          testimage = TSXCreateImage(display, X11DRV_GetVisual(),
  51                          bitmapDepthTable[i], ZPixmap, 0, NULL, 1, 1, 32, 20 );
  52          if( testimage ) ximageDepthTable[i] = testimage->bits_per_pixel;
  53          else return FALSE;
  54          TSXDestroyImage(testimage);
  55     }
  56     return TRUE;
  57 }
  58
  59
  60 /***********************************************************************
  61  *           X11DRV_DIB_GetXImageWidthBytes
  62  *
  63  * Return the width of an X image in bytes
  64  */
  65 int X11DRV_DIB_GetXImageWidthBytes( int width, int depth )
  66 {
  67     int         i;
  68
  69     if (!ximageDepthTable[0]) {
  70             X11DRV_DIB_Init();
  71     }
  72     for( i = 0; bitmapDepthTable[i] ; i++ )
  73          if( bitmapDepthTable[i] == depth )
  74              return (4 * ((width * ximageDepthTable[i] + 31)/32));
  75
  76     WARN("(%d): Unsupported depth\n", depth );
  77     return (4 * width);
  78 }
  79
  80 /***********************************************************************
  81  *           X11DRV_DIB_BuildColorMap
  82  *
  83  * Build the color map from the bitmap palette. Should not be called
  84  * for a >8-bit deep bitmap.
  85  */
  86 int *X11DRV_DIB_BuildColorMap( DC *dc, WORD coloruse, WORD depth,
  87                                const BITMAPINFO *info, int *nColors )
  88 {
  89     int i, colors;
  90     BOOL isInfo;
  91     WORD *colorPtr;
  92     int *colorMapping;
  93
  94     if ((isInfo = (info->bmiHeader.biSize == sizeof(BITMAPINFOHEADER))))
  95     {
  96         colors = info->bmiHeader.biClrUsed;
  97         if (!colors) colors = 1 << info->bmiHeader.biBitCount;
  98         colorPtr = (WORD *)info->bmiColors;
  99     }
 100     else  /* assume BITMAPCOREINFO */
 101     {
 102         colors = 1 << ((BITMAPCOREHEADER *)&info->bmiHeader)->bcBitCount;
 103         colorPtr = (WORD *)((BITMAPCOREINFO *)info)->bmciColors;
 104     }
 105
 106     if (colors > 256)
 107     {
 108         ERR("called with >256 colors!\n");
 109         return NULL;
 110     }
 111
 112     if (!(colorMapping = (int *)HeapAlloc(GetProcessHeap(), 0,
 113                                           colors * sizeof(int) )))
 114         return NULL;
 115
 116     if (coloruse == DIB_RGB_COLORS)
 117     {
 118         if (isInfo)
 119         {
 120             RGBQUAD * rgb = (RGBQUAD *)colorPtr;
 121
 122             if (depth == 1)  /* Monochrome */
 123                 for (i = 0; i < colors; i++, rgb++)
 124                     colorMapping[i] = (rgb->rgbRed + rgb->rgbGreen +
 125                                        rgb->rgbBlue > 255*3/2);
 126             else
 127                 for (i = 0; i < colors; i++, rgb++)
 128                     colorMapping[i] = X11DRV_PALETTE_ToPhysical( dc, RGB(rgb->rgbRed,
 129                                                                 rgb->rgbGreen,
 130                                                                 rgb->rgbBlue));
 131         }
 132         else
 133         {
 134             RGBTRIPLE * rgb = (RGBTRIPLE *)colorPtr;
 135
 136             if (depth == 1)  /* Monochrome */
 137                 for (i = 0; i < colors; i++, rgb++)
 138                     colorMapping[i] = (rgb->rgbtRed + rgb->rgbtGreen +
 139                                        rgb->rgbtBlue > 255*3/2);
 140             else
 141                 for (i = 0; i < colors; i++, rgb++)
 142                     colorMapping[i] = X11DRV_PALETTE_ToPhysical( dc, RGB(rgb->rgbtRed,
 143                                                                rgb->rgbtGreen,
 144                                                                rgb->rgbtBlue));
 145         }
 146     }
 147     else  /* DIB_PAL_COLORS */
 148     {
 149         for (i = 0; i < colors; i++, colorPtr++)
 150             colorMapping[i] = X11DRV_PALETTE_ToPhysical( dc, PALETTEINDEX(*colorPtr) );
 151     }
 152
 153     *nColors = colors;
 154     return colorMapping;
 155 }
 156
 157
 158 /***********************************************************************
 159  *           X11DRV_DIB_MapColor
 160  */
 161 int X11DRV_DIB_MapColor( int *physMap, int nPhysMap, int phys )
 162 {
 163     int color;
 164
 165     for (color = 0; color < nPhysMap; color++)
 166         if (physMap[color] == phys)
 167             return color;
 168
 169     WARN("Strange color %08x\n", phys);
 170     return 0;
 171 }
 172
 173
 174 /*********************************************************************
 175  *         X11DRV_DIB_GetNearestIndex
 176  *
 177  * Helper for X11DRV_DIB_GetDIBits.
 178  * Returns the nearest colour table index for a given RGB.
 179  * Nearest is defined by minimizing the sum of the squares.
 180  */
 181 static INT X11DRV_DIB_GetNearestIndex(RGBQUAD *colormap, int numColors, BYTE r, BYTE g, BYTE b)
 182 {
 183     INT i, best = -1, diff, bestdiff = -1;
 184     RGBQUAD *color;
 185
 186     for(color = colormap, i = 0; i < numColors; color++, i++) {
 187         diff = (r - color->rgbRed) * (r - color->rgbRed) +
 188                (g - color->rgbGreen) * (g - color->rgbGreen) +
 189                (b - color->rgbBlue) * (b - color->rgbBlue);
 190         if(diff == 0)
 191             return i;
 192         if(best == -1 || diff < bestdiff) {
 193             best = i;
 194             bestdiff = diff;
 195         }
 196     }
 197     return best;
 198 }
 199
 200 /***********************************************************************
 201  *           X11DRV_DIB_SetImageBits_1_Line
 202  *
 203  * Handles a single line of 1 bit data.
 204  */
 205 static void X11DRV_DIB_SetImageBits_1_Line(DWORD dstwidth, int left, int *colors,
 206                                     XImage *bmpImage, int h, const BYTE *bits)
 207 {
 208     BYTE pix, extra;
 209     DWORD i, x;
 210
 211     if((extra = (left & 7)) != 0) {
 212         left &= ~7;
 213         dstwidth += extra;
 214     }
 215
 216     bits += left >> 3;
 217
 218     /* FIXME: should avoid putting x<left pixels (minor speed issue) */
 219     for (i = dstwidth/8, x = left; i > 0; i--)
 220     {
 221         pix = *bits++;
 222         XPutPixel( bmpImage, x++, h, colors[pix >> 7] );
 223         XPutPixel( bmpImage, x++, h, colors[(pix >> 6) & 1] );
 224         XPutPixel( bmpImage, x++, h, colors[(pix >> 5) & 1] );
 225         XPutPixel( bmpImage, x++, h, colors[(pix >> 4) & 1] );
 226         XPutPixel( bmpImage, x++, h, colors[(pix >> 3) & 1] );
 227         XPutPixel( bmpImage, x++, h, colors[(pix >> 2) & 1] );
 228         XPutPixel( bmpImage, x++, h, colors[(pix >> 1) & 1] );
 229         XPutPixel( bmpImage, x++, h, colors[pix & 1] );
 230     }
 231     pix = *bits;
 232     switch(dstwidth & 7)
 233     {
 234     case 7: XPutPixel( bmpImage, x++, h, colors[pix >> 7] ); pix <<= 1;
 235     case 6: XPutPixel( bmpImage, x++, h, colors[pix >> 7] ); pix <<= 1;
 236     case 5: XPutPixel( bmpImage, x++, h, colors[pix >> 7] ); pix <<= 1;
 237     case 4: XPutPixel( bmpImage, x++, h, colors[pix >> 7] ); pix <<= 1;
 238     case 3: XPutPixel( bmpImage, x++, h, colors[pix >> 7] ); pix <<= 1;
 239     case 2: XPutPixel( bmpImage, x++, h, colors[pix >> 7] ); pix <<= 1;
 240     case 1: XPutPixel( bmpImage, x++, h, colors[pix >> 7] );
 241     }
 242 }
 243
 244 /***********************************************************************
 245  *           X11DRV_DIB_SetImageBits_1
 246  *
 247  * SetDIBits for a 1-bit deep DIB.
 248  */
 249 static void X11DRV_DIB_SetImageBits_1( int lines, const BYTE *srcbits,
 250                                 DWORD srcwidth, DWORD dstwidth, int left,
 251                                 int *colors, XImage *bmpImage )
 252 {
 253     int h;
 254
 255     /* 32 bit aligned */
 256     DWORD linebytes = ((srcwidth + 31) & ~31) / 8;
 257
 258     if (lines > 0) {
 259         for (h = lines-1; h >=0; h--) {
 260             X11DRV_DIB_SetImageBits_1_Line(dstwidth, left, colors, bmpImage, h,
 261                                            srcbits);
 262             srcbits += linebytes;
 263         }
 264     } else {
 265         lines = -lines;
 266         for (h = 0; h < lines; h++) {
 267             X11DRV_DIB_SetImageBits_1_Line(dstwidth, left, colors, bmpImage, h,
 268                                            srcbits);
 269             srcbits += linebytes;
 270         }
 271     }
 272 }
 273
 274 /***********************************************************************
 275  *           X11DRV_DIB_GetImageBits_1
 276  *
 277  * GetDIBits for a 1-bit deep DIB.
 278  */
 279 static void X11DRV_DIB_GetImageBits_1( int lines, BYTE *dstbits,
 280                                        DWORD dstwidth, DWORD srcwidth,
 281                                        RGBQUAD *colors, PALETTEENTRY *srccolors,
 282                                 XImage *bmpImage )
 283 {
 284     DWORD x;
 285     int h;
 286     BYTE *bits;
 287
 288        /* 32 bit aligned */
 289     DWORD linebytes = ((dstwidth + 31) & ~31) / 8;
 290
 291     if (lines < 0 ) {
 292         lines = -lines;
 293         dstbits = dstbits + linebytes * (lines - 1);
 294         linebytes = -linebytes;
 295     }
 296
 297     bits = dstbits;
 298
 299     switch(bmpImage->depth) {
 300
 301     case 1:
 302        /* ==== monochrome bitmap to monochrome dib ==== */
 303     case 4:
 304        /* ==== 4 colormap bitmap to monochrome dib ==== */
 305        if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
 306          {
 307            PALETTEENTRY val;
 308
 309            for (h = lines - 1; h >= 0; h--) {
 310              for (x = 0; x < dstwidth; x++) {
 311                val = srccolors[XGetPixel(bmpImage, x, h)];
 312                if (!(x&7)) *bits = 0;
 313                *bits |= (X11DRV_DIB_GetNearestIndex(colors, 2,
 314                                                     val.peRed,
 315                                                     val.peGreen,
 316                                                     val.peBlue) << (7 - (x & 7)));
 317                if ((x&7)==7) bits++;
 318              }
 319              bits = (dstbits += linebytes);
 320            }
 321          }
 322        else goto notsupported;
 323
 324        break;
 325
 326     case 8:
 327       /* ==== 8 colormap bitmap to monochrome dib ==== */
 328       if ( bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
 329       {
 330         BYTE *srcpixel;
 331         PALETTEENTRY val;
 332
 333        for( h = lines- 1; h >= 0; h-- ) {
 334           srcpixel = bmpImage->data + (h*bmpImage->bytes_per_line);
 335           for( x = 0; x < dstwidth; x++ ) {
 336             if (!(x&7)) *bits = 0;
 337             val = srccolors[(int)*srcpixel++];
 338             *bits |= ( X11DRV_DIB_GetNearestIndex(colors, 2,
 339                                                   val.peRed,
 340                                                   val.peGreen,
 341                                                   val.peBlue) << (7-(x&7)) );
 342             if ((x&7)==7) bits++;
 343           }
 344           bits = (dstbits += linebytes);
 345         }
 346       }
 347       else goto notsupported;
 348
 349       break;
 350
 351     case 15:
 352       {
 353         LPWORD srcpixel;
 354         WORD val;
 355
 356         /* ==== 555 BGR bitmap to monochrome dib ==== */
 357         if (bmpImage->red_mask == 0x7c00 && bmpImage->blue_mask == 0x1f)
 358         {
 359           for( h = lines - 1; h >= 0; h--) {
 360                 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
 361                 for( x = 0; x < dstwidth; x++) {
 362                   if (!(x&7)) *bits = 0;
 363                   val = *srcpixel++;
 364                   *bits |= (X11DRV_DIB_GetNearestIndex( colors, 2,
 365                                                         ((val >> 7) & 0xf8) |
 366                                                         ((val >> 12) & 0x7),
 367                                                         ((val >> 2) & 0xf8) |
 368                                                         ((val >> 7) & 0x3),
 369                                                         ((val << 3) & 0xf8) |
 370                                                         ((val >> 2) & 0x7) ) << (7-(x&7)) );
 371                   if ((x&7)==7) bits++;
 372                 }
 373                 bits = (dstbits += linebytes);
 374             }
 375         }
 376         /* ==== 555 RGB bitmap to monochrome dib ==== */
 377         else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0xf800)
 378         {
 379             for( h = lines - 1; h >= 0; h--)
 380             {
 381                 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
 382                 for( x = 0; x < dstwidth; x++) {
 383                   if (!(x&1)) *bits = 0;
 384                   val = *srcpixel++;
 385                   *bits |= (X11DRV_DIB_GetNearestIndex( colors, 2,
 386                                                         ((val << 3) & 0xf8) |
 387                                                         ((val >> 2) & 0x7),
 388                                                         ((val >> 2) & 0xf8) |
 389                                                         ((val >> 7) & 0x3),
 390                                                         ((val >> 7) & 0xf8) |
 391                                                         ((val >> 12) &  0x7) ) << (7-(x&7)) );
 392                   if ((x&7)==7) bits++;
 393                 }
 394                 bits = (dstbits += linebytes);
 395             }
 396         }
 397         else goto notsupported;
 398       }
 399       break;
 400
 401     case 16:
 402       {
 403         LPWORD srcpixel;
 404         WORD val;
 405
 406         /* ==== 565 BGR bitmap to monochrome dib ==== */
 407         if (bmpImage->red_mask == 0xf800 && bmpImage->blue_mask == 0x001f)
 408         {
 409             for( h = lines - 1; h >= 0; h--)
 410             {
 411                 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
 412                 for( x = 0; x < dstwidth; x++) {
 413                   if (!(x&7)) *bits = 0;
 414                   val = *srcpixel++;
 415                   *bits |= (X11DRV_DIB_GetNearestIndex( colors, 2,
 416                                                         ((val >> 8) & 0xf8) |
 417                                                         ((val >> 13) & 0x7),
 418                                                         ((val >> 3) & 0xfc) |
 419                                                         ((val >> 9) & 0x3),
 420                                                         ((val << 3) & 0xf8) |
 421                                                         ((val >> 2) & 0x7) ) << (7-(x&7)) );
 422                   if ((x&7)==7) bits++;
 423                 }
 424                 bits = (dstbits += linebytes);
 425             }
 426         }
 427         /* ==== 565 RGB bitmap to monochrome dib ==== */
 428         else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0xf800)
 429         {
 430             for( h = lines - 1; h >= 0; h--)
 431             {
 432                 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
 433                 for( x = 0; x < dstwidth; x++) {
 434                   if (!(x&7)) *bits = 0;
 435                   val = *srcpixel++;
 436                   *bits |= (X11DRV_DIB_GetNearestIndex( colors, 2,
 437                                                         ((val << 3) & 0xf8) |
 438                                                         ((val >> 2) & 0x7),
 439                                                         ((val >> 3) & 0xfc) |
 440                                                         ((val >> 9) & 0x3),
 441                                                         ((val >> 8) & 0xf8) |
 442                                                         ((val >> 13) &  0x7) ) << (7-(x&7)) );
 443                   if ((x&7)==7) bits++;
 444                 }
 445                 bits = (dstbits += linebytes);
 446             }
 447         }
 448         else goto notsupported;
 449       }
 450       break;
 451
 452     case 24:
 453     case 32:
 454       {
 455         BYTE *srcpixel;
 456
 457         /* ==== 24/32 BGR bitmap to monochrome dib ==== */
 458         if (bmpImage->red_mask == 0xff0000 && bmpImage->blue_mask == 0xff)
 459         {
 460           for (h = lines - 1; h >= 0; h--)
 461           {
 462             srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
 463             for (x = 0; x < dstwidth; x++, srcpixel+=4) {
 464               if (!(x&7)) *bits = 0;
 465               *bits |= (X11DRV_DIB_GetNearestIndex(colors, 2, srcpixel[2] , srcpixel[1], srcpixel[0]) << (7-(x&7)) );
 466               if ((x&7)==7) bits++;
 467             }
 468             bits = (dstbits += linebytes);
 469           }
 470         }
 471         /* ==== 24/32 RGB bitmap to monochrome dib ==== */
 472         else if (bmpImage->red_mask == 0xff && bmpImage->blue_mask == 0xff0000)
 473         {
 474           for (h = lines - 1; h >= 0; h--)
 475           {
 476             srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
 477             for (x = 0; x < dstwidth; x++, srcpixel+=4) {
 478                        if (!(x & 7)) *bits = 0;
 479                        *bits |= (X11DRV_DIB_GetNearestIndex(colors, 2, srcpixel[0] , srcpixel[1], srcpixel[2]) << (7-(x&7)) );
 480                        if ((x & 7) == 7) bits++;
 481             }
 482             bits = (dstbits += linebytes);
 483           }
 484         }
 485         else goto notsupported;
 486       }
 487       break;
 488
 489     default: /* ? bit bmp -> monochrome DIB */
 490     notsupported:
 491       {
 492         unsigned long white = (1 << bmpImage->bits_per_pixel) - 1;
 493
 494         FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 1 bit DIB\n",
 495               bmpImage->bits_per_pixel, (int)bmpImage->red_mask,
 496               (int)bmpImage->green_mask, (int)bmpImage->blue_mask );
 497
 498         for( h = lines - 1; h >= 0; h-- ) {
 499           for( x = 0; x < dstwidth; x++ ) {
 500             if (!(x&7)) *bits = 0;
 501             *bits |= (XGetPixel( bmpImage, x, h) >= white)
 502               << (7 - (x&7));
 503             if ((x&7)==7) bits++;
 504           }
 505           bits = (dstbits += linebytes);
 506         }
 507       }
 508       break;
 509     }
 510 }
 511
 512 /***********************************************************************
 513  *           X11DRV_DIB_SetImageBits_4
 514  *
 515  * SetDIBits for a 4-bit deep DIB.
 516  */
 517 static void X11DRV_DIB_SetImageBits_4( int lines, const BYTE *srcbits,
 518                                 DWORD srcwidth, DWORD dstwidth, int left,
 519                                 int *colors, XImage *bmpImage )
 520 {
 521     DWORD i, x;
 522     int h;
 523     const BYTE *bits = srcbits + (left >> 1);
 524
 525     /* 32 bit aligned */
 526     DWORD linebytes = ((srcwidth+7)&~7)/2;
 527
 528     if(left & 1) {
 529         left--;
 530         dstwidth++;
 531     }
 532
 533     if (lines > 0) {
 534         for (h = lines-1; h >= 0; h--) {
 535             for (i = dstwidth/2, x = left; i > 0; i--) {
 536                 BYTE pix = *bits++;
 537                 XPutPixel( bmpImage, x++, h, colors[pix >> 4] );
 538                 XPutPixel( bmpImage, x++, h, colors[pix & 0x0f] );
 539             }
 540             if (dstwidth & 1) XPutPixel( bmpImage, x, h, colors[*bits >> 4] );
 541             srcbits += linebytes;
 542             bits         = srcbits + (left >> 1);
 543         }
 544     } else {
 545         lines = -lines;
 546         for (h = 0; h < lines; h++) {
 547             for (i = dstwidth/2, x = left; i > 0; i--) {
 548                 BYTE pix = *bits++;
 549                 XPutPixel( bmpImage, x++, h, colors[pix >> 4] );
 550                 XPutPixel( bmpImage, x++, h, colors[pix & 0x0f] );
 551             }
 552             if (dstwidth & 1) XPutPixel( bmpImage, x, h, colors[*bits >> 4] );
 553             srcbits += linebytes;
 554             bits         = srcbits + (left >> 1);
 555         }
 556     }
 557 }
 558
 559
 560
 561 /***********************************************************************
 562  *           X11DRV_DIB_GetImageBits_4
 563  *
 564  * GetDIBits for a 4-bit deep DIB.
 565  */
 566 static void X11DRV_DIB_GetImageBits_4( int lines, BYTE *dstbits,
 567                                        DWORD srcwidth, DWORD dstwidth,
 568                                        RGBQUAD *colors, PALETTEENTRY *srccolors,
 569                                        XImage *bmpImage )
 570 {
 571     DWORD x;
 572     int h;
 573     BYTE *bits;
 574     LPBYTE srcpixel;
 575
 576     /* 32 bit aligned */
 577     DWORD linebytes = ((srcwidth+7)&~7)/2;
 578
 579     if (lines < 0 )
 580     {
 581        lines = -lines;
 582        dstbits = dstbits + ( linebytes * (lines-1) );
 583        linebytes = -linebytes;
 584     }
 585
 586     bits = dstbits;
 587
 588     switch(bmpImage->depth) {
 589
 590      case 1:
 591         /* ==== monochrome bitmap to 4 colormap dib ==== */
 592      case 4:
 593        /* ==== 4 colormap bitmap to 4 colormap dib ==== */
 594        if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
 595          {
 596            PALETTEENTRY val;
 597
 598        for (h = lines-1; h >= 0; h--) {
 599              for (x = 0; x < dstwidth; x++) {
 600                if (!(x&1)) *bits = 0;
 601                val = srccolors[XGetPixel(bmpImage, x, h)];
 602                *bits |= (X11DRV_DIB_GetNearestIndex(colors, 16,
 603                                                     val.peRed,
 604                                                     val.peGreen,
 605                                                     val.peBlue) << (4-((x&1)<<2)));
 606                if ((x&1)==1) bits++;
 607            }
 608              bits = (dstbits += linebytes);
 609        }
 610          }
 611        else goto notsupported;
 612
 613        break;
 614
 615     case 8:
 616       /* ==== 8 colormap bitmap to 4 colormap dib ==== */
 617       if ( bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
 618       {
 619         PALETTEENTRY val;
 620
 621         for( h = lines - 1; h >= 0; h-- ) {
 622           srcpixel = bmpImage->data + (h*bmpImage->bytes_per_line);
 623           for( x = 0; x < dstwidth; x++ ) {
 624             if (!(x&1)) *bits = 0;
 625             val = srccolors[(int)*srcpixel++];
 626             *bits |= ( X11DRV_DIB_GetNearestIndex(colors, 16,
 627                                                   val.peRed,
 628                                                   val.peGreen,
 629                                                   val.peBlue) << (4*(1-(x&1))) );
 630             if ((x&1)==1) bits++;
 631           }
 632           bits = (dstbits += linebytes);
 633         }
 634       }
 635       else goto notsupported;
 636
 637       break;
 638
 639     case 15:
 640       {
 641         LPWORD srcpixel;
 642         WORD val;
 643
 644         /* ==== 555 BGR bitmap to 4 colormap dib ==== */
 645         if (bmpImage->red_mask == 0x7c00 && bmpImage->blue_mask == 0x1f)
 646         {
 647           for( h = lines - 1; h >= 0; h--) {
 648                 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
 649                 for( x = 0; x < dstwidth; x++) {
 650                   if (!(x&1)) *bits = 0;
 651                   val = *srcpixel++;
 652                   *bits |= (X11DRV_DIB_GetNearestIndex( colors, 16,
 653                                                         ((val >> 7) & 0xf8) |
 654                                                         ((val >> 12) & 0x7),
 655                                                         ((val >> 2) & 0xf8) |
 656                                                         ((val >> 7) & 0x3),
 657                                                         ((val << 3) & 0xf8) |
 658                                                         ((val >> 2) & 0x7) ) << ((1-(x&1))<<2) );
 659                   if ((x&1)==1) bits++;
 660                 }
 661                 bits = (dstbits += linebytes);
 662             }
 663         }
 664         /* ==== 555 RGB bitmap to 4 colormap dib ==== */
 665         else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0x7c00)
 666         {
 667             for( h = lines - 1; h >= 0; h--)
 668             {
 669                 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
 670                 for( x = 0; x < dstwidth; x++) {
 671                   if (!(x&1)) *bits = 0;
 672                   val = *srcpixel++;
 673                   *bits |= (X11DRV_DIB_GetNearestIndex( colors, 16,
 674                                                         ((val << 3) & 0xf8) |
 675                                                         ((val >> 2) & 0x7),
 676                                                         ((val >> 2) & 0xfc) |
 677                                                         ((val >> 7) & 0x3),
 678                                                         ((val >> 7) & 0xf8) |
 679                                                         ((val >> 12) &  0x7) ) << ((1-(x&1))<<2) );
 680                   if ((x&1)==1) bits++;
 681                 }
 682                 bits = (dstbits += linebytes);
 683             }
 684         }
 685         else goto notsupported;
 686       }
 687       break;
 688
 689     case 16:
 690       {
 691         LPWORD srcpixel;
 692         WORD val;
 693
 694         /* ==== 565 BGR bitmap to 4 colormap dib ==== */
 695         if (bmpImage->red_mask == 0xf800 && bmpImage->blue_mask == 0x001f)
 696         {
 697             for( h = lines - 1; h >= 0; h--)
 698             {
 699                 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
 700                 for( x = 0; x < dstwidth; x++) {
 701                   if (!(x&1)) *bits = 0;
 702                   val = *srcpixel++;
 703                   *bits |= (X11DRV_DIB_GetNearestIndex( colors, 16,
 704                                                         ((val >> 8) & 0xf8) |
 705                                                         ((val >> 13) & 0x7),
 706                                                         ((val >> 3) & 0xfc) |
 707                                                         ((val >> 9) & 0x3),
 708                                                         ((val << 3) & 0xf8) |
 709                                                         ((val >> 2) & 0x7) )  << ((1-(x&1))<<2) );
 710                   if ((x&1)==1) bits++;
 711                 }
 712                 bits = (dstbits += linebytes);
 713             }
 714         }
 715         /* ==== 565 RGB bitmap to 4 colormap dib ==== */
 716         else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0xf800)
 717         {
 718             for( h = lines - 1; h >= 0; h--)
 719             {
 720                 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
 721                 for( x = 0; x < dstwidth; x++) {
 722                   if (!(x&1)) *bits = 0;
 723                   val = *srcpixel++;
 724                   *bits |= (X11DRV_DIB_GetNearestIndex( colors, 16,
 725                                                         ((val << 3) & 0xf8) |
 726                                                         ((val >> 2) & 0x7),
 727                                                         ((val >> 3) & 0xfc) |
 728                                                         ((val >> 9) & 0x3),
 729                                                         ((val >> 8) & 0xf8) |
 730                                                         ((val >> 13) &  0x7) ) << ((1-(x&1))<<2) );
 731                   if ((x&1)==1) bits++;
 732                 }
 733                 bits = (dstbits += linebytes);
 734             }
 735         }
 736         else goto notsupported;
 737       }
 738       break;
 739
 740     case 24:
 741     case 32:
 742       {
 743         BYTE *srcpixel;
 744
 745         /* ==== 24/32 BGR bitmap to 4 colormap dib ==== */
 746         if (bmpImage->red_mask == 0xff0000 && bmpImage->blue_mask == 0xff)
 747         {
 748           for (h = lines - 1; h >= 0; h--)
 749           {
 750             srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
 751             for (x = 0; x < dstwidth; x+=2, srcpixel+=8) /* 2 pixels at a time */
 752               *bits++ = (X11DRV_DIB_GetNearestIndex(colors, 16, srcpixel[2] , srcpixel[1], srcpixel[0]) << 4) |
 753                          X11DRV_DIB_GetNearestIndex(colors, 16, srcpixel[6] , srcpixel[5], srcpixel[4]);
 754             bits = (dstbits += linebytes);
 755           }
 756         }
 757         /* ==== 24/32 RGB bitmap to 4 colormap dib ==== */
 758         else if (bmpImage->red_mask == 0xff && bmpImage->blue_mask == 0xff0000)
 759         {
 760           for (h = lines - 1; h >= 0; h--)
 761           {
 762             srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
 763             for (x = 0; x < dstwidth; x+=2, srcpixel+=8) /* 2 pixels at a time */
 764               *bits++ = (X11DRV_DIB_GetNearestIndex(colors, 16, srcpixel[0] , srcpixel[1], srcpixel[2]) << 4) |
 765                          X11DRV_DIB_GetNearestIndex(colors, 16, srcpixel[4] , srcpixel[5], srcpixel[6]);
 766             bits = (dstbits += linebytes);
 767           }
 768         }
 769         else goto notsupported;
 770       }
 771       break;
 772
 773     default: /* ? bit bmp -> 4 bit DIB */
 774     notsupported:
 775       FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 4 bit DIB\n",
 776             bmpImage->bits_per_pixel, (int)bmpImage->red_mask,
 777             (int)bmpImage->green_mask, (int)bmpImage->blue_mask );
 778       for (h = lines-1; h >= 0; h--) {
 779         for (x = 0; x < dstwidth/2; x++) {
 780           *bits++ = (X11DRV_DIB_MapColor((int *)colors, 16,
 781                                           XGetPixel( bmpImage, x++, h )) << 4)
 782             | (X11DRV_DIB_MapColor((int *)colors, 16,
 783                                         XGetPixel( bmpImage, x++, h )) & 0x0f);
 784            }
 785            if (dstwidth & 1)
 786           *bits = (X11DRV_DIB_MapColor((int *)colors, 16,
 787                                         XGetPixel( bmpImage, x++, h )) << 4);
 788         bits = (dstbits += linebytes);
 789        }
 790       break;
 791     }
 792 }
 793
 794 /***********************************************************************
 795  *           X11DRV_DIB_SetImageBits_RLE4
 796  *
 797  * SetDIBits for a 4-bit deep compressed DIB.
 798  */
 799 static void X11DRV_DIB_SetImageBits_RLE4( int lines, const BYTE *bits,
 800                                           DWORD width, DWORD dstwidth,
 801                                           int left, int *colors,
 802                                           XImage *bmpImage )
 803 {
 804     int x = 0, c, length;
 805     const BYTE *begin = bits;
 806
 807     lines--;
 808
 809     while ((int)lines >= 0) {
 810         length = *bits++;
 811         if (length) {   /* encoded */
 812             c = *bits++;
 813             while (length--) {
 814                 if(x >= width) {
 815                     x = 0;
 816                     if(--lines < 0)
 817                         return;
 818                 }
 819                 XPutPixel(bmpImage, x++, lines, colors[c >>4]);
 820                 if (length) {
 821                     length--;
 822                     if(x >= width) {
 823                         x = 0;
 824                         if(--lines < 0)
 825                             return;
 826                     }
 827                     XPutPixel(bmpImage, x++, lines, colors[c & 0xf]);
 828                 }
 829             }
 830         } else {
 831             length = *bits++;
 832             switch (length) {
 833             case 0: /* eol */
 834                 x = 0;
 835                 lines--;
 836                 continue;
 837
 838             case 1: /* eopicture */
 839                 return;
 840
 841             case 2: /* delta */
 842                 x += *bits++;
 843                 if(x >= width) {
 844                    FIXME_(x11drv)("x-delta is too large?\n");
 845                    return;
 846                 }
 847                 lines -= *bits++;
 848                 continue;
 849
 850             default: /* absolute */
 851                 while (length--) {
 852                     c = *bits++;
 853                     if(x >= width) {
 854                         x = 0;
 855                         if(--lines < 0)
 856                             return;
 857                     }
 858                     XPutPixel(bmpImage, x++, lines, colors[c >> 4]);
 859                     if (length) {
 860                         length--;
 861                         if(x >= width) {
 862                             x = 0;
 863                             if(--lines < 0)
 864                                 return;
 865                         }
 866                         XPutPixel(bmpImage, x++, lines, colors[c & 0xf]);
 867                     }
 868                 }
 869                 if ((bits - begin) & 1)
 870                     bits++;
 871             }
 872         }
 873     }
 874 }
 875
 876
 877
 878 /***********************************************************************
 879  *           X11DRV_DIB_SetImageBits_8
 880  *
 881  * SetDIBits for an 8-bit deep DIB.
 882  */
 883 static void X11DRV_DIB_SetImageBits_8( int lines, const BYTE *srcbits,
 884                                 DWORD srcwidth, DWORD dstwidth, int left,
 885                                 const int *colors, XImage *bmpImage )
 886 {
 887     DWORD x;
 888     int h, color;
 889     const BYTE *bits;
 890
 891     /* align to 32 bit */
 892     DWORD linebytes = (srcwidth + 3) & ~3;
 893
 894     dstwidth += left;
 895
 896     if (lines < 0 )
 897     {
 898         lines = -lines;
 899         srcbits = srcbits + ( linebytes * (lines-1) );
 900         linebytes = -linebytes;
 901     }
 902
 903     bits = srcbits + left;
 904
 905     switch (bmpImage->depth) {
 906     case 15:
 907     case 16:
 908 #if defined(__i386__) && defined(__GNUC__)
 909         /* Some X servers might have 32 bit/ 16bit deep pixel */
 910         if (lines && (dstwidth!=left) && (bmpImage->bits_per_pixel == 16))
 911         {
 912             for (h = lines ; h--; ) {
 913                 int _cl1,_cl2; /* temp outputs for asm below */
 914                 /* Borrowed from DirectDraw */
 915                 __asm__ __volatile__(
 916                 "xor %%eax,%%eax\n"
 917                 "cld\n"
 918                 "1:\n"
 919                 "    lodsb\n"
 920                 "    movw (%%edx,%%eax,4),%%ax\n"
 921                 "    stosw\n"
 922                 "      xor %%eax,%%eax\n"
 923                 "    loop 1b\n"
 924                 :"=S" (bits), "=D" (_cl1), "=c" (_cl2)
 925                 :"S" (bits),
 926                  "D" (bmpImage->data+h*bmpImage->bytes_per_line+left*2),
 927                  "c" (dstwidth-left),
 928                  "d" (colors)
 929                 :"eax", "cc", "memory"
 930                 );
 931                 bits = (srcbits += linebytes) + left;
 932             }
 933             return;
 934         }
 935         break;
 936 #endif
 937     default:
 938         break; /* use slow generic case below */
 939     }
 940
 941     for (h = lines - 1; h >= 0; h--) {
 942         for (x = left; x < dstwidth; x++, bits++) {
 943             color = colors[*bits];
 944             XPutPixel( bmpImage, x, h, colors[*bits] );
 945         }
 946         bits = (srcbits += linebytes) + left;
 947     }
 948 }
 949
 950 /***********************************************************************
 951  *           X11DRV_DIB_GetImageBits_8
 952  *
 953  * GetDIBits for an 8-bit deep DIB.
 954  */
 955 static void X11DRV_DIB_GetImageBits_8( int lines, BYTE *dstbits,
 956                                        DWORD srcwidth, DWORD dstwidth,
 957                                        RGBQUAD *colors, PALETTEENTRY *srccolors,
 958                                        XImage *bmpImage )
 959 {
 960     DWORD x;
 961     int h;
 962     BYTE *bits;
 963
 964     /* align to 32 bit */
 965     DWORD linebytes = (srcwidth + 3) & ~3;
 966
 967     if (lines < 0 )
 968     {
 969        lines = -lines;
 970        dstbits = dstbits + ( linebytes * (lines-1) );
 971        linebytes = -linebytes;
 972     }
 973
 974     bits = dstbits;
 975
 976     /*
 977        Hack for now
 978        This condition is true when GetImageBits has been called by UpdateDIBSection.
 979        For now, GetNearestIndex is too slow to support 256 colormaps, so we'll just use for
 980        for GetDIBits calls. (In somes cases, in a updateDIBSection, the returned colors are bad too)
 981     */
 982     if (!srccolors) goto updatesection;
 983
 984     switch(bmpImage->depth) {
 985
 986     case 1:
 987         /* ==== monochrome bitmap to 8 colormap dib ==== */
 988     case 4:
 989        /* ==== 4 colormap bitmap to 8 colormap dib ==== */
 990        if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
 991          {
 992            PALETTEENTRY val;
 993
 994     for (h = lines - 1; h >= 0; h--) {
 995              for (x = 0; x < dstwidth; x++) {
 996                val = srccolors[XGetPixel(bmpImage, x, h)];
 997                *bits++ = X11DRV_DIB_GetNearestIndex(colors, 256, val.peRed,
 998                                                     val.peGreen, val.peBlue);
 999              }
1000              bits = (dstbits += linebytes);
1001            }
1002          }
1003        else goto notsupported;
1004
1005        break;
1006
1007      case 8:
1008        /* ==== 8 colormap bitmap to 8 colormap dib ==== */
1009        if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
1010          {
1011            BYTE *srcpixel;
1012            PALETTEENTRY val;
1013
1014            for (h = lines - 1; h >= 0; h--) {
1015              srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
1016              for (x = 0; x < dstwidth; x++) {
1017                val = srccolors[(int)*srcpixel++];
1018                *bits++ = X11DRV_DIB_GetNearestIndex(colors, 256, val.peRed,
1019                                                     val.peGreen, val.peBlue);
1020              }
1021              bits = (dstbits += linebytes);
1022            }
1023          }
1024        else goto notsupported;
1025
1026        break;
1027
1028       case 15:
1029       {
1030         LPWORD srcpixel;
1031         WORD val;
1032
1033         /* ==== 555 BGR bitmap to 8 colormap dib ==== */
1034         if (bmpImage->red_mask == 0x7c00 && bmpImage->blue_mask == 0x001f)
1035         {
1036             for( h = lines - 1; h >= 0; h--)
1037             {
1038                 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
1039                 for( x = 0; x < dstwidth; x++ )
1040                 {
1041                   val = *srcpixel++;
1042                   *bits++ = X11DRV_DIB_GetNearestIndex( colors, 256,
1043                                                         ((val >> 7) & 0xf8) |
1044                                                         ((val >> 12) & 0x7),
1045                                                         ((val >> 2) & 0xf8) |
1046                                                         ((val >> 7) & 0x3),
1047                                                         ((val << 3) & 0xf8) |
1048                                                         ((val >> 2) & 0x7) );
1049                 }
1050                 bits = (dstbits += linebytes);
1051             }
1052         }
1053         /* ==== 555 RGB bitmap to 8 colormap dib ==== */
1054         else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0x7c00)
1055         {
1056             for( h = lines - 1; h >= 0; h--)
1057             {
1058                 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
1059                 for( x = 0; x < dstwidth; x++ )
1060                 {
1061                   val = *srcpixel++;
1062                   *bits++ = X11DRV_DIB_GetNearestIndex( colors, 256,
1063                                                         ((val << 3) & 0xf8) |
1064                                                         ((val >> 2) & 0x7),
1065                                                         ((val >> 2) & 0xf8) |
1066                                                         ((val >> 7) & 0x3),
1067                                                         ((val >> 7) & 0xf8) |
1068                                                         ((val >> 12) &  0x7) );
1069                 }
1070                 bits = (dstbits += linebytes);
1071             }
1072         }
1073         else goto notsupported;
1074       }
1075       break;
1076
1077       case 16:
1078       {
1079         LPWORD srcpixel;
1080         WORD val;
1081
1082         /* ==== 565 BGR bitmap to 8 colormap dib ==== */
1083         if (bmpImage->red_mask == 0xf800 && bmpImage->blue_mask == 0x001f)
1084         {
1085             for( h = lines - 1; h >= 0; h--)
1086             {
1087                 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
1088                 for( x = 0; x < dstwidth; x++ )
1089                 {
1090                   val = *srcpixel++;
1091                   *bits++ = X11DRV_DIB_GetNearestIndex( colors, 256,
1092                                                         ((val >> 8) & 0xf8) |
1093                                                         ((val >> 13) & 0x7),
1094                                                         ((val >> 3) & 0xfc) |
1095                                                         ((val >> 9) & 0x3),
1096                                                         ((val << 3) & 0xf8) |
1097                                                         ((val >> 2) & 0x7) );
1098                 }
1099                 bits = (dstbits += linebytes);
1100             }
1101         }
1102         /* ==== 565 RGB bitmap to 8 colormap dib ==== */
1103         else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0xf800)
1104         {
1105             for( h = lines - 1; h >= 0; h--)
1106             {
1107                 srcpixel = (LPWORD)(bmpImage->data + h*bmpImage->bytes_per_line);
1108                 for( x = 0; x < dstwidth; x++ )
1109                 {
1110                   val = *srcpixel++;
1111                   *bits++ = X11DRV_DIB_GetNearestIndex( colors, 256,
1112                                                         ((val << 3) & 0xf8) |
1113                                                         ((val >> 2) & 0x7),
1114                                                         ((val >> 3) & 0x00fc) |
1115                                                         ((val >> 9) & 0x3),
1116                                                         ((val >> 8) & 0x00f8) |
1117                                                         ((val >> 13) &  0x7) );
1118                 }
1119                 bits = (dstbits += linebytes);
1120             }
1121         }
1122         else goto notsupported;
1123       }
1124       break;
1125
1126       case 24:
1127       case 32:
1128       {
1129         BYTE *srcpixel;
1130
1131         /* ==== 24/32 BGR bitmap to 8 colormap dib ==== */
1132         if (bmpImage->red_mask == 0xff0000 && bmpImage->blue_mask == 0xff)
1133         {
1134           for (h = lines - 1; h >= 0; h--)
1135             {
1136               srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
1137               for (x = 0; x < dstwidth; x++, srcpixel+=4)
1138                 *bits++ = X11DRV_DIB_GetNearestIndex(colors, 256,
1139                                                      srcpixel[2] , srcpixel[1], *srcpixel);
1140               bits = (dstbits += linebytes);
1141             }
1142         }
1143         /* ==== 24/32 RGB bitmap to 8 colormap dib ==== */
1144         else if (bmpImage->red_mask == 0xff && bmpImage->blue_mask == 0xff0000)
1145         {
1146           for (h = lines - 1; h >= 0; h--)
1147             {
1148               srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
1149               for (x = 0; x < dstwidth; x++, srcpixel+=4)
1150                 *bits++ = X11DRV_DIB_GetNearestIndex(colors, 256,
1151                                                      *srcpixel, srcpixel[1], srcpixel[2]);
1152               bits = (dstbits += linebytes);
1153             }
1154
1155         }
1156         else goto notsupported;
1157       }
1158       break;
1159
1160     default: /* ? bit bmp -> 8 bit DIB */
1161     notsupported:
1162       FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 8 bit DIB\n",
1163             bmpImage->depth, (int)bmpImage->red_mask,
1164             (int)bmpImage->green_mask, (int)bmpImage->blue_mask );
1165     updatesection:
1166       for (h = lines - 1; h >= 0; h--) {
1167         for (x = 0; x < dstwidth; x++, bits++) {
1168           *bits = X11DRV_DIB_MapColor((int *)colors, 256,
1169                                          XGetPixel( bmpImage, x, h ) );
1170         }
1171         bits = (dstbits += linebytes);
1172       }
1173       break;
1174     }
1175 }
1176
1177 /***********************************************************************
1178  *            X11DRV_DIB_SetImageBits_RLE8
1179  *
1180  * SetDIBits for an 8-bit deep compressed DIB.
1181  *
1182  * This function rewritten 941113 by James Youngman.  WINE blew out when I
1183  * first ran it because my desktop wallpaper is a (large) RLE8 bitmap.
1184  *
1185  * This was because the algorithm assumed that all RLE8 bitmaps end with the
1186  * 'End of bitmap' escape code.  This code is very much laxer in what it
1187  * allows to end the expansion.  Possibly too lax.  See the note by
1188  * case RleDelta.  BTW, MS's documentation implies that a correct RLE8
1189  * bitmap should end with RleEnd, but on the other hand, software exists
1190  * that produces ones that don't and Windows 3.1 doesn't complain a bit
1191  * about it.
1192  *
1193  * (No) apologies for my English spelling.  [Emacs users: c-indent-level=4].
1194  *                      James A. Youngman <mbcstjy@afs.man.ac.uk>
1195  *                                              [JAY]
1196  */
1197
1198 enum Rle8_EscapeCodes
1199 {
1200   /*
1201    * Apologies for polluting your file's namespace...
1202    */
1203   RleEol        = 0,            /* End of line */
1204   RleEnd        = 1,            /* End of bitmap */
1205   RleDelta      = 2             /* Delta */
1206 };
1207
1208 static void X11DRV_DIB_SetImageBits_RLE8( int lines, const BYTE *bits,
1209                                           DWORD width, DWORD dstwidth,
1210                                           int left, int *colors,
1211                                           XImage *bmpImage )
1212 {
1213     int x;                      /* X-positon on each line.  Increases. */
1214     int line;                   /* Line #.  Starts at lines-1, decreases */
1215     const BYTE *pIn = bits;     /* Pointer to current position in bits */
1216     BYTE length;                /* The length pf a run */
1217     BYTE color_index;           /* index into colors[] as read from bits */
1218     BYTE escape_code;           /* See enum Rle8_EscapeCodes.*/
1219     int color;                  /* value of colour[color_index] */
1220
1221     if (lines == 0)             /* Let's hope this doesn't happen. */
1222       return;
1223
1224     /*
1225      * Note that the bitmap data is stored by Windows starting at the
1226      * bottom line of the bitmap and going upwards.  Within each line,
1227      * the data is stored left-to-right.  That's the reason why line
1228      * goes from lines-1 to 0.                  [JAY]
1229      */
1230
1231     x = 0;
1232     line = lines-1;
1233     do
1234       {
1235           length = *pIn++;
1236
1237           /*
1238            * If the length byte is not zero (which is the escape value),
1239            * We have a run of length pixels all the same colour.  The colour
1240            * index is stored next.
1241            *
1242            * If the length byte is zero, we need to read the next byte to
1243            * know what to do.                   [JAY]
1244            */
1245           if (length != 0)
1246             {
1247                 /*
1248                  * [Run-Length] Encoded mode
1249                  */
1250                 color_index = (*pIn++); /* Get the colour index. */
1251                 color = colors[color_index];
1252
1253                 while(length--)
1254                   XPutPixel(bmpImage, x++, line, color);
1255             }
1256           else
1257             {
1258                 /*
1259                  * Escape codes (may be an absolute sequence though)
1260                  */
1261                 escape_code = (*pIn++);
1262                 switch(escape_code)
1263                   {
1264                     case RleEol: /* =0, end of line */
1265                       {
1266                           x = 0;
1267                           line--;
1268                           break;
1269                       }
1270
1271                     case RleEnd: /* =1, end of bitmap */
1272                       {
1273                           /*
1274                            * Not all RLE8 bitmaps end with this
1275                            * code.  For example, Paint Shop Pro
1276                            * produces some that don't.  That's (I think)
1277                            * what caused the previous implementation to
1278                            * fail.                      [JAY]
1279                            */
1280                           line=-1; /* Cause exit from do loop. */
1281                           break;
1282                       }
1283
1284                     case RleDelta: /* =2, a delta */
1285                       {
1286                           /*
1287                            * Note that deltaing to line 0
1288                            * will cause an exit from the loop,
1289                            * which may not be what is intended.
1290                            * The fact that there is a delta in the bits
1291                            * almost certainly implies that there is data
1292                            * to follow.  You may feel that we should
1293                            * jump to the top of the loop to avoid exiting
1294                            * in this case.
1295                            *
1296                            * TODO: Decide what to do here in that case. [JAY]
1297                            */
1298                           x     += (*pIn++);
1299                           line  -= (*pIn++);
1300                           if (line == 0)
1301                             {
1302                               TRACE("Delta to last line of bitmap "
1303                                     "(wrongly?) causes loop exit\n");
1304                             }
1305                           break;
1306                       }
1307
1308                     default:    /* >2, switch to absolute mode */
1309                       {
1310                           /*
1311                            * Absolute Mode
1312                            */
1313                           length = escape_code;
1314                           while(length--)
1315                             {
1316                                 color_index = (*pIn++);
1317                                 XPutPixel(bmpImage, x++, line,
1318                                           colors[color_index]);
1319                             }
1320
1321                           /*
1322                            * If you think for a moment you'll realise that the
1323                            * only time we could ever possibly read an odd
1324                            * number of bytes is when there is a 0x00 (escape),
1325                            * a value >0x02 (absolute mode) and then an odd-
1326                            * length run.  Therefore this is the only place we
1327                            * need to worry about it.  Everywhere else the
1328                            * bytes are always read in pairs.  [JAY]
1329                            */
1330                           if (escape_code & 1)
1331                             pIn++; /* Throw away the pad byte. */
1332                           break;
1333                       }
1334                   } /* switch (escape_code) : Escape sequence */
1335             }  /* process either an encoded sequence or an escape sequence */
1336
1337           /* We expect to come here more than once per line. */
1338       } while (line >= 0);  /* Do this until the bitmap is filled */
1339
1340     /*
1341      * Everybody comes here at the end.
1342      * Check how we exited the loop and print a message if it's a bit odd.
1343      *                                          [JAY]
1344      */
1345     if ( (*(pIn-2) != 0/*escape*/) || (*(pIn-1)!= RleEnd) )
1346       {
1347         TRACE("End-of-bitmap without (strictly) proper escape code.  Last two "
1348               "bytes were: %02X %02X.\n", (int)*(pIn-2),(int)*(pIn-1));
1349       }
1350 }
1351
1352
1353 /***********************************************************************
1354  *           X11DRV_DIB_SetImageBits_16
1355  *
1356  * SetDIBits for a 16-bit deep DIB.
1357  */
1358 static void X11DRV_DIB_SetImageBits_16( int lines, const BYTE *srcbits,
1359                                  DWORD srcwidth, DWORD dstwidth, int left,
1360                                        DC *dc, DWORD rSrc, DWORD gSrc, DWORD bSrc,
1361                                        XImage *bmpImage )
1362 {
1363     DWORD x;
1364     int h;
1365
1366     /* align to 32 bit */
1367     DWORD linebytes = (srcwidth * 2 + 3) & ~3;
1368
1369     if (lines < 0 )
1370     {
1371         lines = -lines;
1372         srcbits = srcbits + ( linebytes * (lines-1));
1373         linebytes = -linebytes;
1374     }
1375
1376     switch ( bmpImage->depth )
1377     {
1378         case 15:
1379             /* using same format as XImage */
1380             if (rSrc == bmpImage->red_mask && gSrc == bmpImage->green_mask && bSrc == bmpImage->blue_mask)
1381                 for (h = lines - 1; h >= 0; h--, srcbits += linebytes)
1382                     memcpy ( bmpImage->data + h * bmpImage->bytes_per_line + left*2, srcbits + left*2, dstwidth*2 );
1383             else     /* We need to do a conversion from a 565 dib */
1384             {
1385                 LPDWORD dstpixel, ptr = (LPDWORD)(srcbits + left*2);
1386                 DWORD val;
1387                 int div = dstwidth % 2;
1388
1389                 for (h = lines - 1; h >= 0; h--) {
1390                     dstpixel = (LPDWORD) (bmpImage->data + h * bmpImage->bytes_per_line + left*2);
1391                     for (x = 0; x < dstwidth/2; x++) { /* Do 2 pixels at a time */
1392                         val = *ptr++;
1393                         *dstpixel++ =   ((val >> 1) & 0x7fe07fe0) | (val & 0x001f001f); /* Red & Green & Blue */
1394                     }
1395                     if (div != 0) /* Odd width? */
1396                         *dstpixel = ((*(WORD *)ptr >> 1) & 0x7fe0) | (*(WORD *)ptr & 0x001f);
1397                     ptr = (LPDWORD) ((srcbits += linebytes) + left*2);
1398                 }
1399             }
1400             break;
1401
1402         case 16:
1403             /* using same format as XImage */
1404             if (rSrc == bmpImage->red_mask && gSrc == bmpImage->green_mask && bSrc == bmpImage->blue_mask)
1405                 for (h = lines - 1; h >= 0; h--, srcbits += linebytes)
1406                     memcpy ( bmpImage->data + h * bmpImage->bytes_per_line + left*2, srcbits + left*2, dstwidth*2 );
1407             else     /* We need to do a conversion from a 555 dib */
1408             {
1409                 LPDWORD dstpixel, ptr = (LPDWORD)(srcbits + left*2);
1410                 DWORD val;
1411                 int div = dstwidth % 2;
1412
1413                 for (h = lines - 1; h >= 0; h--) {
1414                     dstpixel = (LPDWORD) (bmpImage->data + h * bmpImage->bytes_per_line + left*2);
1415                     for (x = 0; x < dstwidth/2; x++) { /* Do 2 pixels at a time */
1416                         val = *ptr++;
1417                         *dstpixel++ = ((val << 1) & 0xffc0ffc0) | ((val >> 4) & 0x00200020) | /* Red & Green */
1418                           (val & 0x001f001f);                             /* Blue */
1419                     }
1420                     if (div != 0) /* Odd width? */
1421                         *dstpixel = ((*(WORD *)ptr << 1) & 0xffc0) | ((*(WORD *)ptr >> 4) & 0x0020)
1422                                     | (*(WORD *)ptr & 0x001f);
1423                     ptr = (LPDWORD) ((srcbits += linebytes) + left*2);
1424                 }
1425             }
1426             break;
1427
1428         case 24:
1429         case 32:
1430             {
1431                 DWORD  *dstpixel;
1432                 LPWORD ptr = (LPWORD)srcbits + left;
1433                 DWORD val;
1434
1435                 /* ==== 555 BGR dib to 24/32 BGR bitmap ==== */
1436                 if (bmpImage->red_mask == 0xff0000 && bmpImage->blue_mask == 0xff)
1437                 {
1438                 for (h = lines - 1; h >= 0; h--) {
1439                     dstpixel = (DWORD *) (bmpImage->data + h * bmpImage->bytes_per_line + left*4);
1440                     for (x = 0; x < dstwidth; x++) {
1441
1442                         val = *ptr++;
1443                         *dstpixel++ = ((val << 9) & 0xf80000) | ((val << 4) & 0x070000) | /* Red */
1444                           ((val << 6) & 0x00f800) | ((val << 1) & 0x000700) | /* Green */
1445                           ((val << 3) & 0x0000f8) | ((val >> 2) & 0x000007);      /* Blue */
1446                     }
1447                     ptr = (LPWORD)(srcbits += linebytes) + left;
1448                 }
1449             }
1450                 /* ==== 555 BGR dib to 24/32 RGB bitmap ==== */
1451                 else if (bmpImage->red_mask == 0xff && bmpImage->blue_mask == 0xff0000)
1452                 {
1453                   for (h = lines - 1; h >= 0; h--) {
1454                     dstpixel = (DWORD *) (bmpImage->data + h * bmpImage->bytes_per_line + left*4);
1455                     for (x = 0; x < dstwidth; x++) {
1456
1457                         val = *ptr++;
1458                         *dstpixel++ = ((val >> 7) & 0x0000f8) | ((val >> 12) & 0x000007) | /* Red */
1459                           ((val << 6) & 0x00f800) | ((val << 1) & 0x000700) | /* Green */
1460                           ((val << 19) & 0xf80000) | ((val >> 14) & 0x070000);      /* Blue */
1461                     }
1462                     ptr = (LPWORD)(srcbits += linebytes) + left;
1463                   }
1464                 }
1465
1466             }
1467             break;
1468
1469         case 1:
1470         case 4:
1471         case 8:
1472             {
1473                 LPWORD ptr = (LPWORD)srcbits + left;
1474                 WORD val;
1475                 int sc1, sc2;
1476
1477                 /* Set color scaling values */
1478                 if ( rSrc == 0x7c00 ) { sc1 = 7; sc2 = 2; }             /* 555 dib */
1479                 else { sc1 = 8; sc2 = 3; }                              /* 565 dib */
1480
1481                 for (h = lines - 1; h >= 0; h--) {
1482                     for (x = left; x < dstwidth+left; x++) {
1483                         val = *ptr++;
1484                         XPutPixel( bmpImage, x, h,
1485                                    X11DRV_PALETTE_ToPhysical(dc, RGB(((val & rSrc) >> sc1),  /* Red */
1486                                                                      ((val & gSrc) >> sc2),  /* Green */
1487                                                                      ((val & bSrc) << 3)))); /* Blue */
1488                     }
1489                     ptr = (LPWORD) (srcbits += linebytes) + left;
1490                 }
1491             }
1492             break;
1493
1494         default:
1495             FIXME("16 bit DIB %d bit bitmap\n", bmpImage->bits_per_pixel);
1496         break;
1497
1498     }
1499 }
1500
1501
1502 /***********************************************************************
1503  *           X11DRV_DIB_GetImageBits_16
1504  *
1505  * GetDIBits for an 16-bit deep DIB.
1506  */
1507 static void X11DRV_DIB_GetImageBits_16( int lines, BYTE *dstbits,
1508                                         DWORD dstwidth, DWORD srcwidth,
1509                                         PALETTEENTRY *srccolors, XImage *bmpImage )
1510 {
1511     DWORD x;
1512     int h;
1513
1514     /* align to 32 bit */
1515     DWORD linebytes = (dstwidth * 2 + 3) & ~3;
1516
1517     if (lines < 0 )
1518     {
1519         lines = -lines;
1520         dstbits = dstbits + ( linebytes * (lines-1));
1521         linebytes = -linebytes;
1522     }
1523
1524     switch ( bmpImage->depth )
1525     {
1526         case 15:
1527             /* ==== 555 BGR bitmap to 555 BGR dib ==== */
1528             if (bmpImage->red_mask == 0x7c00 && bmpImage->blue_mask == 0x001f)
1529                 for (h = lines - 1; h >= 0; h--, dstbits += linebytes)
1530                     memcpy( dstbits, bmpImage->data + h*bmpImage->bytes_per_line, srcwidth*2 );
1531
1532             /* ==== 555 RGB bitmap to 555 BGR dib ==== */
1533             else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0x7c00)
1534             {
1535                 LPDWORD srcpixel, ptr = (LPDWORD)dstbits;
1536                 DWORD val;
1537                 int div = srcwidth % 2;
1538
1539                 for (h = lines - 1; h >= 0; h--) {
1540                     srcpixel = (LPDWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
1541                     for (x = 0; x < srcwidth/2; x++) {  /* Do 2 pixels at a time */
1542                         val = *srcpixel++;
1543                         *ptr++ = ((val << 10) & 0xf800f800) | (val & 0x03e003e0) |        /* Red & Green */
1544                           ((val >> 10) & 0x001f001f);                                     /* Blue */
1545                     }
1546                     if (div != 0) /* Odd width? */
1547                         *ptr = ((*(WORD *)srcpixel << 1) & 0xffc0) | ((*(WORD *)srcpixel >> 4) & 0x0020) |
1548                                (*(WORD *)srcpixel & 0x001f);
1549                     ptr = (LPDWORD)(dstbits += linebytes);
1550                }
1551            }
1552            else goto notsupported;
1553
1554            break;
1555
1556        case 16:
1557            {
1558            LPDWORD srcpixel, ptr = (LPDWORD)dstbits;
1559            DWORD val;
1560            int div = srcwidth % 2;
1561
1562            /* ==== 565 BGR bitmap to 555 BGR dib ==== */
1563            if (bmpImage->red_mask == 0xf800 && bmpImage->blue_mask == 0x001f )
1564            {
1565                for (h = lines - 1; h >= 0; h--) {
1566                    srcpixel = (LPDWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
1567                    for (x = 0; x < srcwidth/2; x++) {  /* Do 2 pixels at a time */
1568                        val = *srcpixel++;
1569                        *ptr++ = ((val >> 1) & 0x7fe07fe0) |                    /* Red & Green */
1570                          (val & 0x001f001f);                                   /* Blue */
1571                    }
1572                    if (div != 0) /* Odd width? */
1573                        *ptr = ((*(WORD *)srcpixel >> 1) & 0x7fe0) | (*(WORD *)srcpixel & 0x001f);
1574                    ptr = (LPDWORD) (dstbits += linebytes);
1575                }
1576            }
1577            /* ==== 565 RGB bitmap to 555 BGR dib ==== */
1578            else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0xf800)
1579            {
1580                for (h = lines - 1; h >= 0; h--) {
1581                    srcpixel = (LPDWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
1582                    for (x = 0; x < srcwidth/2; x++) {  /* Do 2 pixels at a time */
1583                        val = *srcpixel++;
1584                        *ptr++ = ((val << 10) & 0x7c007c00) | ((val >> 1) & 0x03e003e0) |   /* Red & Green */
1585                          ((val >> 11) & 0x001f001f);                                       /* Blue */
1586                    }
1587                    if (div != 0) /* Odd width? */
1588                        *ptr = ((*(WORD *)srcpixel >> 1) & 0x7fe0) | (*(WORD *)srcpixel & 0x001f);
1589                    ptr = (LPDWORD) (dstbits += linebytes);
1590                }
1591                }
1592            else goto notsupported;
1593            }
1594            break;
1595
1596        case 24:
1597        case 32:
1598            {
1599                DWORD  *srcpixel;
1600                LPWORD ptr = (LPWORD)dstbits;
1601                DWORD val;
1602
1603                /* ==== 24/32 BGR bitmap to 555 BGR dib ==== */
1604                if (bmpImage->red_mask == 0xff0000 && bmpImage->blue_mask == 0xff)
1605                {
1606                for (h = lines - 1; h >= 0; h--) {
1607                    srcpixel = (DWORD *) (bmpImage->data + h * bmpImage->bytes_per_line);
1608                    for (x = 0; x < srcwidth; x++, ptr++) {
1609                        val = *srcpixel++;
1610                        *ptr = ((val >> 9) & 0x7c00) |                               /* Red */
1611                               ((val >> 6) & 0x03e0) |                               /* Green */
1612                               ((val >> 3) & 0x001f);                                /* Blue */
1613                    }
1614                    ptr = (LPWORD)(dstbits += linebytes);
1615                    }
1616                }
1617                /* ==== 24/32 RGB bitmap to 555 BGR dib ==== */
1618                else if (bmpImage->red_mask == 0xff && bmpImage->blue_mask == 0xff0000)
1619                {
1620                  for (h = lines - 1; h >= 0; h--) {
1621                    srcpixel = (DWORD *) (bmpImage->data + h * bmpImage->bytes_per_line);
1622                    for (x = 0; x < srcwidth; x++, ptr++) {
1623                        val = *srcpixel++;
1624                        *ptr = ((val << 7) & 0x7c00) |                              /* Red */
1625                               ((val >> 6) & 0x03e0) |                              /* Green */
1626                               ((val >> 19) & 0x001f);                              /* Blue */
1627                    }
1628                    ptr = (LPWORD) (dstbits += linebytes);
1629                }
1630            }
1631                else goto notsupported;
1632            }
1633            break;
1634
1635        case 1:
1636             /* ==== monochrome bitmap to 16 BGR dib ==== */
1637        case 4:
1638             /* ==== 4 colormap bitmap to 16 BGR dib ==== */
1639             if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
1640            {
1641                 LPWORD ptr = (LPWORD)dstbits;
1642                 PALETTEENTRY val;
1643
1644                 for (h = lines - 1; h >= 0; h--) {
1645                   for (x = 0; x < dstwidth; x++) {
1646                     val = srccolors[XGetPixel(bmpImage, x, h)];
1647                     *ptr++ = ((val.peRed << 7) & 0x7c00) |
1648                              ((val.peGreen << 2) & 0x03e0) |
1649                              ((val.peBlue >> 3) & 0x001f);
1650                   }
1651                   ptr = (LPWORD)(dstbits += linebytes);
1652                 }
1653             }
1654             else goto notsupported;
1655
1656             break;
1657
1658         case 8:
1659             /* ==== 8 colormap bitmap to 16 BGR dib ==== */
1660             if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
1661             {
1662                 LPWORD ptr = (LPWORD)dstbits;
1663                 BYTE *srcpixel;
1664                 PALETTEENTRY val;
1665
1666                for (h = lines - 1; h >= 0; h--) {
1667                   srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
1668                   for (x = 0; x < dstwidth; x++) {
1669                     val = srccolors[(int)*srcpixel++];
1670                     *ptr++ = ((val.peRed << 7) & 0x7c00) |
1671                              ((val.peGreen << 2) & 0x03e0) |
1672                              ((val.peBlue >> 3) & 0x001f);
1673                    }
1674                   ptr = (LPWORD)(dstbits += linebytes);
1675                }
1676            }
1677             else goto notsupported;
1678
1679            break;
1680
1681        default:
1682        notsupported:
1683             {
1684               BYTE r,g, b;
1685               LPWORD ptr = (LPWORD)dstbits;
1686
1687               FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 16 bit DIB\n",
1688                     bmpImage->depth, (int)bmpImage->red_mask,
1689                     (int)bmpImage->green_mask, (int)bmpImage->blue_mask );
1690               for (h = lines - 1; h >= 0; h--)
1691                 {
1692                   for (x = 0; x < dstwidth; x++, ptr++)
1693                     {
1694                       COLORREF pixel = X11DRV_PALETTE_ToLogical( XGetPixel( bmpImage, x, h ) );
1695                       r = (BYTE) GetRValue(pixel);
1696                       g = (BYTE) GetGValue(pixel);
1697                       b = (BYTE) GetBValue(pixel);
1698                       *ptr = ( ((r << 7) & 0x7c00) | ((g << 2) & 0x03e0) | ((b >> 3) & 0x001f) );
1699                     }
1700                   ptr = (LPWORD) (dstbits += linebytes);
1701                 }
1702             }
1703            break;
1704    }
1705 }
1706
1707
1708 /***********************************************************************
1709  *           X11DRV_DIB_SetImageBits_24
1710  *
1711  * SetDIBits for a 24-bit deep DIB.
1712  */
1713 static void X11DRV_DIB_SetImageBits_24( int lines, const BYTE *srcbits,
1714                                  DWORD srcwidth, DWORD dstwidth, int left,
1715                                  DC *dc, XImage *bmpImage )
1716 {
1717     DWORD x;
1718     int h;
1719
1720     /* align to 32 bit */
1721     DWORD linebytes = (srcwidth * 3 + 3) & ~3;
1722
1723     if (lines < 0 )
1724     {
1725         lines = -lines;
1726         srcbits = srcbits + linebytes * (lines - 1);
1727         linebytes = -linebytes;
1728     }
1729
1730     switch ( bmpImage->depth )
1731     {
1732         case 24:
1733             {
1734                 if (bmpImage->bits_per_pixel == 24) {
1735                         int dstlinebytes = linebytes;
1736                         BYTE *dstpixel;
1737                         BYTE *ptr = (BYTE *)(srcbits+left*3);
1738
1739                         if (dstlinebytes < 0 ) dstlinebytes = -dstlinebytes;
1740                         dstpixel = bmpImage->data + lines*dstlinebytes + left*3;
1741                         for(h = lines ; h-- ; ) {
1742                                 dstpixel-=dstlinebytes;
1743                                 memcpy(dstpixel,ptr,dstwidth*3);
1744                                 ptr +=linebytes;
1745                         }
1746                         break;
1747                 }
1748             }
1749         case 32:
1750             {
1751                 if( bmpImage->blue_mask == 0xff && bmpImage->red_mask == 0xff0000 )  /* packed BGR to unpacked BGR */
1752                 {
1753                     DWORD *dstpixel, val, buf;
1754                     DWORD *ptr = (DWORD *)(srcbits + left*3);
1755                     BYTE *bits;
1756                     int div = dstwidth % 4;
1757                     int divk;
1758
1759                     for(h = lines - 1; h >= 0; h--)
1760                     {
1761                         dstpixel = (DWORD *) (bmpImage->data + h*bmpImage->bytes_per_line + left*4);
1762
1763                         for (x = 0; x < dstwidth/4; x++) {   /* do 3 dwords source, 4 dwords dest at a time */
1764                             buf = *ptr++;
1765                             *dstpixel++ = buf&0x00ffffff;                  /* b1, g1, r1 */
1766                             val = (buf >> 24);                             /* b2 */
1767                             buf = *ptr++;
1768                             *dstpixel++ = (val | (buf<<8)) &0x00ffffff;    /* g2, r2 */
1769                             val = (buf >> 16);                             /* b3, g3 */
1770                             buf = *ptr++;
1771                             *dstpixel++ = (val | (buf<<16)) &0x00ffffff;   /* r3 */
1772                             *dstpixel++ = (buf >> 8);                      /* b4, g4, r4 */
1773                         }
1774                         for ( divk=div, bits=(BYTE*)ptr; divk>0; divk--, bits+=3 ) /* do remainder */
1775                         {
1776                             *dstpixel++ = *(DWORD*)bits & 0x00ffffff;      /* b, g, r */
1777                         }
1778                         ptr = (DWORD*)((srcbits+=linebytes)+left*3);
1779                     }
1780                 }
1781                 else if( bmpImage->blue_mask == 0xff0000 && bmpImage->red_mask == 0xff )  /* packed BGR to unpacked RGB */
1782                 {
1783                     DWORD *dstpixel, val, buf;
1784                     DWORD *ptr = (DWORD *)(srcbits + left*3);
1785                     BYTE *bits;
1786                     int div = dstwidth % 4;
1787                     int divk;
1788
1789                     for(h = lines - 1; h >= 0; h--)
1790                     {
1791                         dstpixel = (DWORD *) (bmpImage->data + h*bmpImage->bytes_per_line + left*4);
1792
1793                         for (x = 0; x < dstwidth/4; x++) {   /* do 3 dwords source, 4 dwords dest at a time */
1794                             buf = *ptr++;
1795                             *dstpixel++ = ((buf&0xff)<<16) | (buf&0xff00) | ((buf&0xff0000)>>16);  /* b1, g1, r1 */
1796                             val = ((buf&0xff000000)>>8);                                           /* b2 */
1797                             buf = *ptr++;
1798                             *dstpixel++ = val | ((buf&0xff)<<8) | ((buf&0xff00)>>8);               /* g2, r2 */
1799                             val = (buf&0xff0000) | ((buf&0xff000000)>>16);                         /* b3, g3 */
1800                             buf = *ptr++;
1801                             *dstpixel++ = val | (buf&0xff);                                        /* r3 */
1802                             *dstpixel++ = ((buf&0xff00)<<8) | ((buf&0xff0000)>>8) | (buf>>24);     /* b4, g4, r4 */
1803                         }
1804                         for ( divk=div, bits=(BYTE*)ptr; divk>0; divk--, bits+=3 ) /* do remainder */
1805                         {
1806                             buf = *(DWORD*)bits;
1807                             *dstpixel++ = ((buf&0xff)<<16) | (buf&0xff00) | ((buf&0xff0000)>>16);  /* b, g, r */
1808                         }
1809                         ptr = (DWORD*)((srcbits+=linebytes)+left*3);
1810                     }
1811                 }
1812                 else
1813                     goto notsupported;
1814             }
1815             break;
1816
1817         case 15:
1818             {
1819                 if( bmpImage->blue_mask == 0x7c00 && bmpImage->red_mask == 0x1f )   /* BGR888 to RGB555 */
1820                 {
1821                     DWORD  *ptr = (DWORD *)(srcbits + left*3), val;
1822                     LPBYTE bits;
1823                     LPWORD dstpixel;
1824                     int div = dstwidth % 4;
1825                     int divk;
1826
1827                     for (h = lines - 1; h >= 0; h--) {              /* Do 4 pixels at a time */
1828                         dstpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line + left*2);
1829                         for (x = 0; x < dstwidth/4; x++) {
1830                             *dstpixel++ = (WORD)((((val = *ptr++) << 7) & 0x7c00) | ((val >> 6) & 0x03e0) | ((val >> 19) & 0x1f));
1831                             *dstpixel++ = (WORD)(((val >> 17) & 0x7c00) | (((val = *ptr++) << 2) & 0x03e0) | ((val >> 11) & 0x1f));
1832                             *dstpixel++ = (WORD)(((val >> 9) & 0x07c00) | ((val >> 22) & 0x03e0) | (((val = *ptr++) >> 3) & 0x1f));
1833                             *dstpixel++ = (WORD)(((val >> 1) & 0x07c00) | ((val >> 14) & 0x03e0) | ((val >> 27) & 0x1f));
1834                         }
1835                         for (bits = (LPBYTE)ptr, divk=div; divk > 0; divk--, bits+=3)  /* dstwidth not divisible by 4? */
1836                             *dstpixel++ = (((WORD)bits[0] << 7) & 0x07c00) |
1837                                             (((WORD)bits[1] << 2) & 0x03e0) |
1838                                             (((WORD)bits[2] >> 3) & 0x001f);
1839                         ptr = (DWORD *)((srcbits += linebytes) + left * 3);
1840                     }
1841                 }
1842                 else if( bmpImage->blue_mask == 0x1f && bmpImage->red_mask == 0x7c00 )   /* BGR888 to BGR555 */
1843                 {
1844                     DWORD  *ptr = (DWORD *)(srcbits + left*3), val;
1845                     LPBYTE bits;
1846                     LPWORD dstpixel;
1847                     int div = dstwidth % 4;
1848                     int divk;
1849
1850                     for (h = lines - 1; h >= 0; h--) {              /* Do 4 pixels at a time */
1851                         dstpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line + left*2);
1852                         for (x = 0; x < dstwidth/4; x++) {
1853                             *dstpixel++ = (WORD)((((val = *ptr++) >> 3) & 0x1f) | ((val >> 6) & 0x03e0) | ((val >> 9) & 0x7c00));
1854                             *dstpixel++ = (WORD)(((val >> 27) & 0x1f) | (((val = *ptr++) << 2) & 0x03e0) | ((val >> 1) & 0x7c00));
1855                             *dstpixel++ = (WORD)(((val >> 19) & 0x1f) | ((val >> 22) & 0x03e0) | (((val = *ptr++) << 7) & 0x7c00));
1856                             *dstpixel++ = (WORD)(((val >> 11) & 0x1f) | ((val >> 14) & 0x03e0) | ((val >> 17) & 0x7c00));
1857                         }
1858                         for (bits = (LPBYTE)ptr, divk=div; divk > 0; divk--, bits+=3)  /* dstwidth not divisible by 4? */
1859                             *dstpixel++ = (((WORD)bits[2] << 7) & 0x07c00) |
1860                                             (((WORD)bits[1] << 2) & 0x03e0) |
1861                                             (((WORD)bits[0] >> 3) & 0x001f);
1862                         ptr = (DWORD *)((srcbits += linebytes) + left * 3);
1863                     }
1864                 }
1865                 else
1866                     goto notsupported;
1867             }
1868             break;
1869
1870         case 16:
1871             {
1872                 DWORD  *ptr = (DWORD *)(srcbits + left*3), val;
1873                 LPBYTE bits;
1874                 LPWORD dstpixel;
1875                 int div = dstwidth % 4;
1876                 int divk;
1877
1878                 if( bmpImage->blue_mask == 0x001f && bmpImage->red_mask == 0xf800 )    /* BGR888 to BGR565 */
1879                 {
1880                     for (h = lines - 1; h >= 0; h--) {              /* Do 4 pixels at a time */
1881                         dstpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line + left*2);
1882                         for (x = 0; x < dstwidth/4; x++) {
1883                             *dstpixel++ = (WORD)((((val = *ptr++) >> 3) & 0x1f) | ((val >> 5) & 0x07e0) | ((val >> 8) & 0xf800));
1884                             *dstpixel++ = (WORD)(((val >> 27) & 0x1f) | (((val = *ptr++) << 3) & 0x07e0) | ((val) & 0xf800));
1885                             *dstpixel++ = (WORD)(((val >> 19) & 0x1f) | ((val >> 21) & 0x07e0) | (((val = *ptr++) << 8) & 0xf800));
1886                             *dstpixel++ = (WORD)(((val >> 11) & 0x1f) | ((val >> 13) & 0x07e0) | ((val >> 16) & 0xf800));
1887                         }
1888                         for (   bits = (LPBYTE)ptr, divk=div; divk > 0; divk--, bits+=3)  /* dstwidth is not divisible by 4? */
1889                             *dstpixel++ = (((WORD)bits[2] << 8) & 0xf800) |
1890                                             (((WORD)bits[1] << 3) & 0x07e0) |
1891                                             (((WORD)bits[0] >> 3) & 0x001f);
1892                         ptr = (DWORD *)((srcbits += linebytes) + left * 3);
1893                     }
1894                 }
1895                 else if( bmpImage->blue_mask == 0xf800 && bmpImage->red_mask == 0x001f ) /* BGR888 to RGB565 */
1896                 {
1897                     for (h = lines - 1; h >= 0; h--) {              /* Do 4 pixels at a time */
1898                         dstpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line + left*2);
1899                         for (x = 0; x < dstwidth/4; x++) {
1900                             *dstpixel++ = (WORD)((((val = *ptr++) << 8) & 0xf800) | ((val >> 5) & 0x07e0) | ((val >> 19) & 0x1f));
1901                             *dstpixel++ = (WORD)(((val >> 16) & 0xf800) | (((val = *ptr++) << 3) & 0x07e0) | ((val >> 11) & 0x1f));
1902                             *dstpixel++ = (WORD)(((val >> 8) & 0xf800) | ((val >> 21) & 0x07e0) | (((val = *ptr++) >> 3) & 0x1f));
1903                             *dstpixel++ = (WORD)((val & 0xf800) | ((val >> 13) & 0x07e0) | ((val >> 27) & 0x1f));
1904                         }
1905                         for (   bits = (LPBYTE)ptr, divk=div; divk > 0; divk--, bits+=3)  /* dstwidth is not divisible by 4? */
1906                             *dstpixel++ = (((WORD)bits[0] << 8) & 0xf800) |
1907                                             (((WORD)bits[1] << 3) & 0x07e0) |
1908                                             (((WORD)bits[2] >> 3) & 0x001f);
1909                         ptr = (DWORD *)((srcbits += linebytes) + left * 3);
1910                     }
1911                 }
1912                 else
1913                     goto notsupported;
1914             }
1915             break;
1916
1917         case 1:
1918         case 4:
1919         case 8:
1920             {
1921                 LPBYTE bits = (LPBYTE)srcbits + left*3;
1922
1923                 for (h = lines - 1; h >= 0; h--) {
1924                     for (x = left; x < dstwidth+left; x++, bits+=3)
1925                         XPutPixel( bmpImage, x, h,
1926                                    X11DRV_PALETTE_ToPhysical(dc, RGB(bits[2], bits[1], bits[0])));
1927                     bits = (LPBYTE)(srcbits += linebytes) + left * 3;
1928                 }
1929             }
1930             break;
1931
1932         default:
1933         notsupported:
1934             FIXME("from 24 bit DIB to %d bit bitmap with mask R,G,B %x,%x,%x\n",
1935                   bmpImage->bits_per_pixel, (int)bmpImage->red_mask,
1936                   (int)bmpImage->green_mask, (int)bmpImage->blue_mask );
1937             break;
1938     }
1939 }
1940
1941
1942 /***********************************************************************
1943  *           X11DRV_DIB_GetImageBits_24
1944  *
1945  * GetDIBits for an 24-bit deep DIB.
1946  */
1947 static void X11DRV_DIB_GetImageBits_24( int lines, BYTE *dstbits,
1948                                         DWORD dstwidth, DWORD srcwidth,
1949                                         PALETTEENTRY *srccolors, XImage *bmpImage )
1950 {
1951     DWORD x, val;
1952     int h;
1953
1954     /* align to 32 bit */
1955     DWORD linebytes = (dstwidth * 3 + 3) & ~3;
1956
1957     if (lines < 0 )
1958     {
1959         lines = -lines;
1960         dstbits = dstbits + ( linebytes * (lines-1) );
1961         linebytes = -linebytes;
1962     }
1963
1964     switch ( bmpImage->depth )
1965     {
1966         case 24:
1967             {
1968                 if (bmpImage->bits_per_pixel == 24) {
1969                         int tocopy = linebytes;
1970                         BYTE *srcpixel;
1971                         BYTE *ptr = (LPBYTE)dstbits;
1972
1973                         if (tocopy < 0 ) tocopy = -tocopy;
1974                         srcpixel = bmpImage->data + lines*tocopy;
1975                         for(h = lines ; h-- ; ) {
1976                                 srcpixel-=tocopy;
1977                                 memcpy(ptr,srcpixel,tocopy);
1978                                 ptr = (LPBYTE)(dstbits+=linebytes);
1979                         }
1980                         break;
1981                 }
1982             }
1983         case 32:
1984             {
1985                     DWORD  *srcpixel, buf;
1986                     LPBYTE bits;
1987             DWORD *ptr=(DWORD *)dstbits;
1988                     int quotient = dstwidth / 4;
1989                     int remainder = dstwidth % 4;
1990                     int remk;
1991
1992             /* ==== 24/32 BGR bitmap to 24 BGR dib==== */
1993             if( bmpImage->blue_mask == 0xff && bmpImage->red_mask == 0xff0000 )
1994             {
1995                     for(h = lines - 1; h >= 0; h--)
1996                     {
1997                   srcpixel = (DWORD *) (bmpImage->data + h * bmpImage->bytes_per_line);
1998
1999                         for (x = 0; x < quotient; x++) {     /* do 4 dwords source, 3 dwords dest at a time*/
2000                           buf = ((*srcpixel++)&0x00ffffff);      /* b1, g1, r1*/
2001                           *ptr++ = buf | ((*srcpixel)<<24);      /* b2 */
2002                           buf = ((*srcpixel++>>8)&0x0000ffff);   /* g2, r2 */
2003                           *ptr++ = buf | ((*srcpixel)<<16);      /* b3, g3 */
2004                           buf = ((*srcpixel++>>16)&0x000000ff);  /* r3 */
2005                           *ptr++ = buf | ((*srcpixel++)<<8);     /* b4, g4, r4 */
2006                         }
2007                         for ( remk=remainder, bits=(BYTE*)ptr; remk>0; remk--, bits+=3 ) /* do remainder */
2008                         {
2009                             buf=*srcpixel++;
2010                             *(WORD*)bits = buf;                    /* b, g */
2011                           *(bits+2) = buf>>16;                   /* r */
2012                         }
2013                   ptr = (DWORD*)(dstbits+=linebytes);
2014                     }
2015
2016                 }
2017             /* ==== 24/32 RGB bitmap to 24 BGR dib ==== */
2018             else if( bmpImage->blue_mask == 0xff0000 && bmpImage->red_mask == 0xff )
2019                 {
2020                     for(h = lines - 1; h >= 0; h--)
2021                     {
2022                   srcpixel = (DWORD *) (bmpImage->data + h * bmpImage->bytes_per_line);
2023
2024                         for (x = 0; x < quotient; x++) {     /* do 4 dwords source, 3 dwords dest at a time */
2025                             buf = *srcpixel++;
2026                             val = ((buf&0xff0000)>>16) | (buf&0xff00) | ((buf&0xff)<<16);       /* b1, g1, r1 */
2027                             buf = *srcpixel++;
2028                             *ptr++ = val | ((buf&0xff0000)<<8);                                 /* b2 */
2029                             val = ((buf&0xff00)>>8) | ((buf&0xff)<<8);                          /* g2, r2 */
2030                             buf = *srcpixel++;
2031                             *ptr++ = val | (buf&0xff0000) | ((buf&0xff00)<<16);                 /* b3, g3 */
2032                             val = (buf&0xff);                                                   /* r3 */
2033                             buf = *srcpixel++;
2034                             *ptr++ = val | ((buf&0xff0000)>>8) | ((buf&0xff00)<<8) | (buf<<24); /* b4, g4, r4 */
2035                         }
2036                         for ( remk=remainder, bits=(BYTE*)ptr; remk>0; remk--, bits+=3 ) /* do remainder */
2037                         {
2038                             buf=*srcpixel++;
2039                             *(WORD*)bits = (buf&0xff00) | ((buf&0xff0000)>>16) ;                /* b, g */
2040                             *(bits+2) = buf;                                                    /* r */
2041                         }
2042                   ptr = (DWORD*)(dstbits+=linebytes);
2043                     }
2044                 }
2045             else goto notsupported;
2046             }
2047             break;
2048
2049         case 15:
2050             {
2051                 LPWORD srcpixel;
2052             LPBYTE bits = dstbits;
2053                 WORD val;
2054
2055             /* ==== 555 BGR bitmap to 24 BGR dib ==== */
2056             if( bmpImage->blue_mask == 0x1f && bmpImage->red_mask == 0x7c00 )
2057                 {
2058                     for (h = lines - 1; h >= 0; h--) {
2059                   srcpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2060                         for (x = 0; x < srcwidth; x++, bits += 3) {
2061                             val = *srcpixel++;
2062                             bits[2] = (BYTE)(((val >> 7) & 0xf8) | ((val >> 12) & 0x07));           /*Red*/
2063                             bits[1] = (BYTE)(((val >> 2) & 0xf8) | ((val >> 7) & 0x07));            /*Green*/
2064                             bits[0] = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x07));            /*Blue*/
2065                         }
2066                   bits = (dstbits += linebytes);
2067                     }
2068                 }
2069             /* ==== 555 RGB bitmap to 24 RGB dib==== */
2070             else if( bmpImage->blue_mask == 0x7c00 && bmpImage->red_mask == 0x1f )
2071                 {
2072                     for (h = lines - 1; h >= 0; h--) {
2073                   srcpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2074                         for (x = 0; x < srcwidth; x++, bits += 3) {
2075                             val = *srcpixel++;
2076                             bits[0] = (BYTE)(((val >> 7) & 0xf8) | ((val >> 12) & 0x07));           /*Red*/
2077                             bits[1] = (BYTE)(((val >> 2) & 0xf8) | ((val >> 7) & 0x07));            /*Green*/
2078                             bits[2] = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x07));            /*Blue*/
2079                         }
2080                   bits = (dstbits += linebytes);
2081                     }
2082                 }
2083             else goto notsupported;
2084             }
2085             break;
2086
2087         case 16:
2088             {
2089                 LPWORD srcpixel;
2090             LPBYTE bits = dstbits;
2091                 WORD val;
2092
2093             /* ==== 565 BGR bitmap to 24 BGR dib ==== */
2094             if( bmpImage->blue_mask == 0x1f && bmpImage->red_mask == 0xf800 )
2095                 {
2096                     for (h = lines - 1; h >= 0; h--) {
2097                   srcpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2098                         for (x = 0; x < srcwidth; x++, bits += 3) {
2099                             val = *srcpixel++;
2100                             bits[2] = (BYTE)(((val >> 8) & 0xf8) | ((val >> 13) & 0x07));           /*Red*/
2101                             bits[1] = (BYTE)(((val >> 3) & 0xfc) | ((val >> 9) & 0x03));            /*Green*/
2102                             bits[0] = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x07));            /*Blue*/
2103                         }
2104                   bits = (dstbits += linebytes);
2105                     }
2106                 }
2107             /* ==== 565 RGB bitmap to 24 BGR dib ==== */
2108             else if( bmpImage->blue_mask == 0xf800 && bmpImage->red_mask == 0x1f )
2109                 {
2110                     for (h = lines - 1; h >= 0; h--) {
2111                   srcpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2112                         for (x = 0; x < srcwidth; x++, bits += 3) {
2113                             val = *srcpixel++;
2114                             bits[0] = (BYTE)(((val >> 8) & 0xf8) | ((val >> 13) & 0x07));           /*Red*/
2115                             bits[1] = (BYTE)(((val >> 3) & 0xfc) | ((val >> 9) & 0x03));            /*Green*/
2116                             bits[2] = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x07));            /*Blue*/
2117                         }
2118                   bits = (dstbits += linebytes);
2119                     }
2120                 }
2121             else  goto notsupported;
2122             }
2123             break;
2124
2125         case 1:
2126             /* ==== monochrome bitmap to 24 BGR dib ==== */
2127         case 4:
2128             /* ==== 4 colormap bitmap to 24 BGR dib ==== */
2129             if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
2130             {
2131                 LPBYTE bits = dstbits;
2132                 PALETTEENTRY val;
2133
2134                 for (h = lines - 1; h >= 0; h--) {
2135                   for (x = 0; x < dstwidth; x++) {
2136                     val = srccolors[XGetPixel(bmpImage, x, h)];
2137                     *bits++ = val.peBlue;
2138                     *bits++ = val.peGreen;
2139                     *bits++ = val.peRed;
2140                   }
2141                   bits = (dstbits += linebytes);
2142                 }
2143             }
2144             else goto notsupported;
2145
2146             break;
2147
2148         case 8:
2149             /* ==== 8 colormap bitmap to 24 BGR dib ==== */
2150             if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask == 0 && srccolors)
2151             {
2152                 BYTE *srcpixel;
2153                 LPBYTE bits = dstbits;
2154                 PALETTEENTRY val;
2155
2156                 for (h = lines - 1; h >= 0; h--) {
2157                   srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
2158                   for (x = 0; x < dstwidth; x++ ) {
2159                     val = srccolors[(int)*srcpixel++];
2160                     *bits++ = val.peBlue;               /*Blue*/
2161                     *bits++ = val.peGreen;              /*Green*/
2162                     *bits++ = val.peRed;                /*Red*/
2163                     }
2164                   bits = (dstbits += linebytes);
2165                 }
2166             }
2167             else goto notsupported;
2168
2169             break;
2170
2171         default:
2172         notsupported:
2173             {
2174               LPBYTE bits = dstbits;
2175
2176             FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 24 bit DIB\n",
2177                   bmpImage->depth, (int)bmpImage->red_mask,
2178                   (int)bmpImage->green_mask, (int)bmpImage->blue_mask );
2179               for (h = lines - 1; h >= 0; h--)
2180                 {
2181                   for (x = 0; x < dstwidth; x++, bits += 3)
2182                     {
2183                       COLORREF pixel = X11DRV_PALETTE_ToLogical( XGetPixel( bmpImage, x, h ) );
2184                       bits[0] = GetBValue(pixel);
2185                       bits[1] = GetGValue(pixel);
2186                       bits[2] = GetRValue(pixel);
2187                     }
2188                   bits = (dstbits += linebytes);
2189                 }
2190             }
2191             break;
2192     }
2193 }
2194
2195
2196 /***********************************************************************
2197  *           X11DRV_DIB_SetImageBits_32
2198  *
2199  * SetDIBits for a 32-bit deep DIB.
2200  */
2201 static void X11DRV_DIB_SetImageBits_32( int lines, const BYTE *srcbits,
2202                                  DWORD srcwidth, DWORD dstwidth, int left,
2203                                         DC *dc, XImage *bmpImage )
2204 {
2205     DWORD x, *ptr;
2206     int h;
2207
2208     DWORD linebytes = (srcwidth * 4);
2209
2210     if (lines < 0 )
2211     {
2212        lines = -lines;
2213        srcbits = srcbits + ( linebytes * (lines-1) );
2214        linebytes = -linebytes;
2215     }
2216
2217     ptr = (DWORD *) srcbits + left;
2218
2219     switch ( bmpImage->depth )
2220     {
2221         case 24:
2222         case 32:
2223             /* ==== 32 BGR dib to 24/32 BGR bitmap ==== */
2224             if (bmpImage->red_mask == 0xff0000 && bmpImage->blue_mask == 0xff) {
2225                 for (h = lines - 1; h >= 0; h--, srcbits+=linebytes) {
2226                     memcpy( bmpImage->data + h * bmpImage->bytes_per_line, srcbits + left*4, dstwidth*4 );
2227                 }
2228             }
2229
2230             /* ==== 32 BGR dib to 24/32 RGB bitmap ==== */
2231             else if (bmpImage->red_mask == 0xff && bmpImage->blue_mask == 0xff0000)
2232             {
2233                 DWORD *dstpixel;
2234
2235                 for (h = lines - 1; h >= 0; h--) {
2236                     dstpixel = (DWORD *) (bmpImage->data + h * bmpImage->bytes_per_line);
2237                     for (x = 0; x < dstwidth; x++, ptr++) {
2238                         *dstpixel++ =   ((*ptr << 16) & 0xff0000) | (*ptr & 0xff00) | ((*ptr >> 16) & 0xff);
2239                     }
2240                     ptr = (DWORD *) (srcbits += linebytes) + left;
2241                 }
2242             }
2243             else goto notsupported;
2244
2245             break;
2246
2247         case 15:
2248             /* ==== 32 BGR dib to 555 BGR bitmap ==== */
2249             if (bmpImage->red_mask == 0x7c00 && bmpImage->blue_mask == 0x001f)
2250             {
2251                 LPWORD  dstpixel;
2252
2253                 for (h = lines - 1; h >= 0; h--) {
2254                     dstpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2255                     for (x = 0; x < dstwidth; x++, ptr++) {
2256                         *dstpixel++ = (WORD) (((*ptr >> 9) & 0x7c00) | ((*ptr >> 6) & 0x03e0) | ((*ptr >> 3) & 0x001f));
2257                     }
2258                     ptr = (DWORD *) (srcbits += linebytes) + left;
2259                 }
2260             }
2261             /* ==== 32 BGR dib to 555 RGB bitmap ==== */
2262             else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0x7c00)
2263             {
2264                 LPWORD  dstpixel;
2265
2266                 for (h = lines - 1; h >= 0; h--) {
2267                     dstpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2268                     for (x = 0; x < dstwidth; x++, ptr++) {
2269                         *dstpixel++ = (WORD) (((*ptr << 7) & 0x7c00) | ((*ptr >> 6) & 0x03e0) | ((*ptr >> 19) & 0x001f));
2270                     }
2271                     ptr = (DWORD *) (srcbits += linebytes) + left;
2272                 }
2273             }
2274             else goto notsupported;
2275
2276             break;
2277
2278         case 16:
2279             /* ==== 32 BGR dib to 565 BGR bitmap ==== */
2280             if (bmpImage->red_mask == 0xf800 && bmpImage->blue_mask == 0x001f)
2281             {
2282                 LPWORD  dstpixel;
2283
2284                 for (h = lines - 1; h >= 0; h--) {
2285                     dstpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2286                     for (x = 0; x < dstwidth; x++, ptr++) {
2287                         *dstpixel++ = (WORD) (((*ptr >> 8) & 0xf800) | ((*ptr >> 5) & 0x07e0) | ((*ptr >> 3) & 0x001f));
2288                     }
2289                     ptr = (DWORD *) (srcbits += linebytes) + left;
2290                 }
2291             }
2292             /* ==== 32 BGR dib to 565 RGB bitmap ==== */
2293             else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0xf800)
2294             {
2295                 LPWORD dstpixel;
2296
2297                 for (h = lines - 1; h >= 0; h--) {
2298                     dstpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2299                     for (x = 0; x < dstwidth; x++, ptr++) {
2300                         *dstpixel++ = (WORD) (((*ptr << 8) & 0xf800) | ((*ptr >> 5) & 0x07e0) | ((*ptr >> 19) & 0x001f));
2301                     }
2302                     ptr = (DWORD *) (srcbits += linebytes) + left;
2303                 }
2304             }
2305             else goto notsupported;
2306
2307             break;
2308
2309         case 1:
2310         case 4:
2311         case 8:
2312             {
2313                 LPBYTE bits = (LPBYTE)srcbits + left*4;
2314
2315                 for (h = lines - 1; h >= 0; h--) {
2316                     for (x = left; x < dstwidth+left; x++, bits += 4)
2317                         XPutPixel( bmpImage, x, h,
2318                                    X11DRV_PALETTE_ToPhysical(dc, RGB( bits[2],  bits[1], *bits )));
2319                     bits = (LPBYTE)(srcbits += linebytes) + left * 4;
2320                 }
2321             }
2322             break;
2323
2324        default:
2325        notsupported:
2326             FIXME("32 bit DIB %d bit bitmap\n", bmpImage->bits_per_pixel);
2327             break;
2328     }
2329
2330 }
2331
2332 /***********************************************************************
2333  *           X11DRV_DIB_GetImageBits_32
2334  *
2335  * GetDIBits for an 32-bit deep DIB.
2336  */
2337 static void X11DRV_DIB_GetImageBits_32( int lines, BYTE *dstbits,
2338                                         DWORD dstwidth, DWORD srcwidth,
2339                                         PALETTEENTRY *srccolors, XImage *bmpImage )
2340 {
2341     DWORD x;
2342     int h;
2343     BYTE *bits;
2344
2345     /* align to 32 bit */
2346     DWORD linebytes = (srcwidth * 4);
2347     DWORD copybytes = linebytes;
2348
2349     if (lines < 0 )
2350     {
2351         lines = -lines;
2352         dstbits = dstbits + ( linebytes * (lines-1) );
2353         linebytes = -linebytes;
2354     }
2355
2356     bits = dstbits;
2357
2358     switch ( bmpImage->depth )
2359     {
2360         case 24:
2361         case 32:
2362             /* ==== 24/32 BGR bitmap to 32 BGR dib ==== */
2363             if ( bmpImage->red_mask == 0xff0000 && bmpImage->blue_mask == 0xff )
2364                 for (h = lines - 1; h >= 0; h--, dstbits+=linebytes)
2365                     memcpy( dstbits, bmpImage->data + h*bmpImage->bytes_per_line, copybytes );
2366
2367             /* ==== 24/32 RGB bitmap to 32 BGR dib ==== */
2368             else if ( bmpImage->red_mask == 0xff && bmpImage->blue_mask == 0xff0000 )
2369             {
2370                 LPBYTE srcbits;
2371
2372                 for (h = lines - 1; h >= 0; h--) {
2373                     srcbits = bmpImage->data + h * bmpImage->bytes_per_line;
2374                     for (x = 0; x < dstwidth; x++, bits+=4, srcbits+=2) {
2375                         *(bits + 2) = *srcbits++;
2376                         *(bits + 1) = *srcbits++;
2377                         *bits = *srcbits;
2378                     }
2379                     bits = (dstbits += linebytes);
2380                 }
2381             }
2382             else goto notsupported;
2383             break;
2384
2385         case 15:
2386             {
2387                 LPWORD srcpixel;
2388                 WORD val;
2389
2390             /* ==== 555 BGR bitmap to 32 BGR dib ==== */
2391             if (bmpImage->red_mask == 0x7c00 && bmpImage->blue_mask == 0x001f)
2392             {
2393               for (h = lines - 1; h >= 0; h--) {
2394                 srcpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2395                 for (x = 0; x < dstwidth; x++, bits+=2) {
2396                   val = *srcpixel++;
2397                   *bits++ = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x03)); /*Blue*/
2398                   *bits++ = (BYTE)(((val >> 2) & 0xfc) | ((val >> 8) & 0x03)); /*Green*/
2399                   *bits = (BYTE)(((val >> 7) & 0xf8) | ((val >> 12) & 0x07));  /*Red*/
2400                 }
2401                 bits = (dstbits += linebytes);
2402               }
2403             }
2404             /* ==== 555 RGB bitmap to 32 BGR dib ==== */
2405             else if (bmpImage->red_mask == 0x001f && bmpImage->blue_mask == 0x7c00)
2406             {
2407                 for (h = lines - 1; h >= 0; h--) {
2408                 srcpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2409                 for (x = 0; x < dstwidth; x++, bits+=2) {
2410                         val = *srcpixel++;
2411                   *bits++ = (BYTE)(((val >> 7) & 0xf8) | ((val >> 12) & 0x07));/*Blue*/
2412                   *bits++ = (BYTE)(((val >> 2) & 0xfc) | ((val >> 8) & 0x03)); /*Green*/
2413                   *bits = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x03));   /*Red*/
2414                 }
2415                 bits = (dstbits += linebytes);
2416                     }
2417                 }
2418             else goto notsupported;
2419             }
2420             break;
2421
2422         case 16:
2423             {
2424                 LPWORD srcpixel;
2425                 WORD val;
2426
2427             /* ==== 565 BGR bitmap to 32 BGR dib ==== */
2428             if (bmpImage->red_mask == 0xf800 && bmpImage->blue_mask == 0x001f)
2429             {
2430                 for (h = lines - 1; h >= 0; h--) {
2431                 srcpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2432                 for (x = 0; x < srcwidth; x++, bits+=2) {
2433                         val = *srcpixel++;
2434                   *bits++ = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x03)); /*Blue*/
2435                   *bits++ = (BYTE)(((val >> 3) & 0xfc) | ((val >> 9) & 0x03)); /*Green*/
2436                   *bits = (BYTE)(((val >> 8) & 0xf8) | ((val >> 13) & 0x07));  /*Red*/
2437                 }
2438                 bits = (dstbits += linebytes);
2439               }
2440             }
2441             /* ==== 565 RGB bitmap to 32 BGR dib ==== */
2442             else if (bmpImage->red_mask == 0xf800 && bmpImage->blue_mask == 0x001f)
2443             {
2444               for (h = lines - 1; h >= 0; h--) {
2445                 srcpixel = (LPWORD) (bmpImage->data + h * bmpImage->bytes_per_line);
2446                 for (x = 0; x < srcwidth; x++, bits+=2) {
2447                   val = *srcpixel++;
2448                   *bits++ = (BYTE)(((val >> 8) & 0xf8) | ((val >> 13) & 0x07));/*Blue*/
2449                   *bits++ = (BYTE)(((val >> 3) & 0xfc) | ((val >> 9) & 0x03)); /*Green*/
2450                   *bits = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x03));   /*Red*/
2451                 }
2452                 bits = (dstbits += linebytes);
2453                     }
2454                 }
2455             else goto notsupported;
2456             }
2457             break;
2458
2459         case 1:
2460             /* ==== monochrome bitmap to 32 BGR dib ==== */
2461         case 4:
2462             /* ==== 4 colormap bitmap to 32 BGR dib ==== */
2463             if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
2464             {
2465                 PALETTEENTRY val;
2466
2467                 for (h = lines - 1; h >= 0; h--) {
2468                   for (x = 0; x < dstwidth; x++) {
2469                     val = srccolors[XGetPixel(bmpImage, x, h)];
2470                     *bits++ = val.peBlue;
2471                     *bits++ = val.peGreen;
2472                     *bits++ = val.peRed;
2473                     *bits++ = 0;
2474                   }
2475                   bits = (dstbits += linebytes);
2476                 }
2477             }
2478             else goto notsupported;
2479
2480             break;
2481
2482         case 8:
2483             /* ==== 8 colormap bitmap to 32 BGR dib ==== */
2484             if (bmpImage->red_mask==0 && bmpImage->green_mask==0 && bmpImage->blue_mask==0 && srccolors)
2485             {
2486                 BYTE *srcpixel;
2487                 PALETTEENTRY val;
2488
2489                 for (h = lines - 1; h >= 0; h--) {
2490                   srcpixel = bmpImage->data + h*bmpImage->bytes_per_line;
2491                   for (x = 0; x < dstwidth; x++) {
2492                     val = srccolors[(int)*srcpixel++];
2493                     *bits++ = val.peBlue;               /*Blue*/
2494                     *bits++ = val.peGreen;              /*Green*/
2495                     *bits++ = val.peRed;                /*Red*/
2496                     *bits++ = 0;
2497                     }
2498                   bits = (dstbits += linebytes);
2499                 }
2500             }
2501             else goto notsupported;
2502             break;
2503
2504         default:
2505         notsupported:
2506             FIXME("from %d bit bitmap with mask R,G,B %x,%x,%x to 32 bit DIB\n",
2507                   bmpImage->depth, (int)bmpImage->red_mask,
2508                   (int)bmpImage->green_mask, (int)bmpImage->blue_mask );
2509             for (h = lines - 1; h >= 0; h--)
2510               {
2511                 for (x = 0; x < dstwidth; x++, bits += 4)
2512                   {
2513                     COLORREF pixel = X11DRV_PALETTE_ToLogical( XGetPixel( bmpImage, x, h ) );
2514                     bits[0] = GetBValue(pixel);
2515                     bits[1] = GetGValue(pixel);
2516                     bits[2] = GetRValue(pixel);
2517                   }
2518                 bits = (dstbits += linebytes);
2519               }
2520             break;
2521     }
2522 }
2523
2524 /***********************************************************************
2525  *           X11DRV_DIB_SetImageBits
2526  *
2527  * Transfer the bits to an X image.
2528  * Helper function for SetDIBits() and SetDIBitsToDevice().
2529  * The Xlib critical section must be entered before calling this function.
2530  */
2531 int X11DRV_DIB_SetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
2532 {
2533     int lines = descr->lines >= 0 ? descr->lines : -descr->lines;
2534     XImage *bmpImage;
2535
2536     if ( descr->dc && descr->dc->w.flags & DC_DIRTY )
2537         CLIPPING_UpdateGCRegion( descr->dc );
2538
2539     if (descr->image)
2540         bmpImage = descr->image;
2541     else {
2542         bmpImage = XCreateImage( display, X11DRV_GetVisual(), descr->depth, ZPixmap, 0, NULL,
2543                                  descr->infoWidth, lines, 32, 0 );
2544         bmpImage->data = calloc( lines, bmpImage->bytes_per_line );
2545         if(bmpImage->data == NULL) {
2546             ERR("Out of memory!");
2547             XDestroyImage( bmpImage );
2548             return lines;
2549         }
2550     }
2551
2552       /* Transfer the pixels */
2553     switch(descr->infoBpp)
2554     {
2555     case 1:
2556         X11DRV_DIB_SetImageBits_1( descr->lines, descr->bits, descr->infoWidth,
2557                                    descr->width, descr->xSrc, (int *)(descr->colorMap),
2558                                    bmpImage );
2559         break;
2560     case 4:
2561         if (descr->compression) {
2562             XGetSubImage( display, descr->drawable, descr->xDest, descr->yDest,
2563                           descr->width, descr->height, AllPlanes, ZPixmap,
2564                           bmpImage, descr->xSrc, descr->ySrc );
2565
2566             X11DRV_DIB_SetImageBits_RLE4( descr->lines, descr->bits,
2567                                           descr->infoWidth, descr->width,
2568                                           descr->xSrc, (int *)(descr->colorMap),
2569                                           bmpImage );
2570         } else
2571             X11DRV_DIB_SetImageBits_4( descr->lines, descr->bits,
2572                                        descr->infoWidth, descr->width,
2573                                        descr->xSrc, (int*)(descr->colorMap),
2574                                        bmpImage );
2575         break;
2576     case 8:
2577         if (descr->compression) {
2578             XGetSubImage( display, descr->drawable, descr->xDest, descr->yDest,
2579                           descr->width, descr->height, AllPlanes, ZPixmap,
2580                           bmpImage, descr->xSrc, descr->ySrc );
2581             X11DRV_DIB_SetImageBits_RLE8( descr->lines, descr->bits,
2582                                           descr->infoWidth, descr->width,
2583                                           descr->xSrc, (int *)(descr->colorMap),
2584                                           bmpImage );
2585         } else
2586             X11DRV_DIB_SetImageBits_8( descr->lines, descr->bits,
2587                                        descr->infoWidth, descr->width,
2588                                        descr->xSrc, (int *)(descr->colorMap),
2589                                        bmpImage );
2590         break;
2591     case 15:
2592     case 16:
2593         X11DRV_DIB_SetImageBits_16( descr->lines, descr->bits,
2594                                     descr->infoWidth, descr->width,
2595                                    descr->xSrc, descr->dc,
2596                                    descr->rMask, descr->gMask, descr->bMask,
2597                                    bmpImage);
2598         break;
2599     case 24:
2600         X11DRV_DIB_SetImageBits_24( descr->lines, descr->bits,
2601                                     descr->infoWidth, descr->width,
2602                                     descr->xSrc, descr->dc, bmpImage );
2603         break;
2604     case 32:
2605         X11DRV_DIB_SetImageBits_32( descr->lines, descr->bits,
2606                                     descr->infoWidth, descr->width,
2607                                    descr->xSrc, descr->dc,
2608                                    bmpImage);
2609         break;
2610     default:
2611         WARN("(%d): Invalid depth\n", descr->infoBpp );
2612         break;
2613     }
2614
2615     if (descr->useShm)
2616     {
2617         XShmPutImage( display, descr->drawable, descr->gc, bmpImage,
2618                       descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
2619                       descr->width, descr->height, FALSE );
2620         XSync( display, 0 );
2621     }
2622     else
2623         XPutImage( display, descr->drawable, descr->gc, bmpImage,
2624                    descr->xSrc, descr->ySrc, descr->xDest, descr->yDest,
2625                    descr->width, descr->height );
2626
2627     if (!descr->image) XDestroyImage( bmpImage );
2628     return lines;
2629 }
2630
2631 /***********************************************************************
2632  *           X11DRV_DIB_GetImageBits
2633  *
2634  * Transfer the bits from an X image.
2635  * The Xlib critical section must be entered before calling this function.
2636  */
2637 int X11DRV_DIB_GetImageBits( const X11DRV_DIB_IMAGEBITS_DESCR *descr )
2638 {
2639     int lines = descr->lines >= 0 ? descr->lines : -descr->lines;
2640     XImage *bmpImage;
2641
2642     if (descr->image)
2643         bmpImage = descr->image;
2644     else {
2645         bmpImage = XCreateImage( display, X11DRV_GetVisual(), descr->depth, ZPixmap, 0, NULL,
2646                                  descr->infoWidth, lines, 32, 0 );
2647         bmpImage->data = calloc( lines, bmpImage->bytes_per_line );
2648         if(bmpImage->data == NULL) {
2649             ERR("Out of memory!");
2650             XDestroyImage( bmpImage );
2651             return lines;
2652         }                                                                           }
2653
2654     XGetSubImage( display, descr->drawable, descr->xDest, descr->yDest,
2655                   descr->width, descr->height, AllPlanes, ZPixmap,
2656                   bmpImage, descr->xSrc, descr->ySrc );
2657
2658       /* Transfer the pixels */
2659     switch(descr->infoBpp)
2660     {
2661     case 1:
2662           X11DRV_DIB_GetImageBits_1( descr->lines,(LPVOID)descr->bits,
2663                                      descr->infoWidth, descr->width,
2664                                      descr->colorMap, descr->palentry,
2665                                      bmpImage );
2666        break;
2667
2668     case 4:
2669        if (descr->compression)
2670            FIXME("Compression not yet supported!\n");
2671        else
2672            X11DRV_DIB_GetImageBits_4( descr->lines,(LPVOID)descr->bits,
2673                                       descr->infoWidth, descr->width,
2674                                       descr->colorMap, descr->palentry,
2675                                       bmpImage );
2676        break;
2677
2678     case 8:
2679        if (descr->compression)
2680            FIXME("Compression not yet supported!\n");
2681        else
2682            X11DRV_DIB_GetImageBits_8( descr->lines, (LPVOID)descr->bits,
2683                                       descr->infoWidth, descr->width,
2684                                       descr->colorMap, descr->palentry,
2685                                       bmpImage );
2686        break;
2687     case 15:
2688     case 16:
2689        X11DRV_DIB_GetImageBits_16( descr->lines, (LPVOID)descr->bits,
2690                                    descr->infoWidth,descr->width,
2691                                    descr->palentry, bmpImage );
2692        break;
2693
2694     case 24:
2695        X11DRV_DIB_GetImageBits_24( descr->lines, (LPVOID)descr->bits,
2696                                    descr->infoWidth,descr->width,
2697                                    descr->palentry, bmpImage );
2698        break;
2699
2700     case 32:
2701        X11DRV_DIB_GetImageBits_32( descr->lines, (LPVOID)descr->bits,
2702                                    descr->infoWidth, descr->width,
2703                                    descr->palentry, bmpImage );
2704        break;
2705
2706     default:
2707         WARN("(%d): Invalid depth\n", descr->infoBpp );
2708         break;
2709     }
2710
2711     if (!descr->image) XDestroyImage( bmpImage );
2712     return lines;
2713 }
2714
2715 /*************************************************************************
2716  *              X11DRV_SetDIBitsToDevice
2717  *
2718  */
2719 INT X11DRV_SetDIBitsToDevice( DC *dc, INT xDest, INT yDest, DWORD cx,
2720                                 DWORD cy, INT xSrc, INT ySrc,
2721                                 UINT startscan, UINT lines, LPCVOID bits,
2722                                 const BITMAPINFO *info, UINT coloruse )
2723 {
2724     X11DRV_DIB_IMAGEBITS_DESCR descr;
2725     DWORD width, oldcy = cy;
2726     INT result;
2727     int height, tmpheight;
2728     X11DRV_PDEVICE *physDev = (X11DRV_PDEVICE *)dc->physDev;
2729
2730
2731     if (DIB_GetBitmapInfo( &info->bmiHeader, &width, &height,
2732                            &descr.infoBpp, &descr.compression ) == -1)
2733         return 0;
2734     tmpheight = height;
2735     if (height < 0) height = -height;
2736     if (!lines || (startscan >= height)) return 0;
2737     if (startscan + lines > height) lines = height - startscan;
2738     if (ySrc < startscan) ySrc = startscan;
2739     else if (ySrc >= startscan + lines) return 0;
2740     if (xSrc >= width) return 0;
2741     if (ySrc + cy >= startscan + lines) cy = startscan + lines - ySrc;
2742     if (xSrc + cx >= width) cx = width - xSrc;
2743     if (!cx || !cy) return 0;
2744
2745     X11DRV_SetupGCForText( dc );  /* To have the correct colors */
2746     TSXSetFunction(display, physDev->gc, X11DRV_XROPfunction[dc->w.ROPmode-1]);
2747
2748     switch (descr.infoBpp)
2749     {
2750        case 1:
2751        case 4:
2752        case 8:
2753                descr.colorMap = (RGBQUAD *)X11DRV_DIB_BuildColorMap(
2754                                             coloruse == DIB_PAL_COLORS ? dc : NULL, coloruse,
2755                                             dc->w.bitsPerPixel, info, &descr.nColorMap );
2756                if (!descr.colorMap) return 0;
2757                descr.rMask = descr.gMask = descr.bMask = 0;
2758                break;
2759        case 15:
2760        case 16:
2761                descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors : 0x7c00;
2762                descr.gMask = (descr.compression == BI_BITFIELDS) ?  *((DWORD *)info->bmiColors + 1) : 0x03e0;
2763                descr.bMask = (descr.compression == BI_BITFIELDS) ?  *((DWORD *)info->bmiColors + 2) : 0x001f;
2764                descr.colorMap = 0;
2765                break;
2766
2767        case 24:
2768                descr.rMask = descr.gMask = descr.bMask = 0;
2769                descr.colorMap = 0;
2770                break;
2771
2772        case 32:
2773                descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors : 0xff0000;
2774                descr.gMask = (descr.compression == BI_BITFIELDS) ?  *((DWORD *)info->bmiColors + 1) : 0xff00;
2775                descr.bMask = (descr.compression == BI_BITFIELDS) ?  *((DWORD *)info->bmiColors + 2) : 0xff;
2776                descr.colorMap = 0;
2777                break;
2778     }
2779
2780     descr.dc        = dc;
2781     descr.bits      = bits;
2782     descr.image     = NULL;
2783     descr.palentry  = NULL;
2784     descr.lines     = tmpheight >= 0 ? lines : -lines;
2785     descr.infoWidth = width;
2786     descr.depth     = dc->w.bitsPerPixel;
2787     descr.drawable  = physDev->drawable;
2788     descr.gc        = physDev->gc;
2789     descr.xSrc      = xSrc;
2790     descr.ySrc      = tmpheight >= 0 ? lines-(ySrc-startscan)-cy+(oldcy-cy)
2791                                      : ySrc - startscan;
2792     descr.xDest     = dc->w.DCOrgX + XLPTODP( dc, xDest );
2793     descr.yDest     = dc->w.DCOrgY + YLPTODP( dc, yDest ) +
2794                                      (tmpheight >= 0 ? oldcy-cy : 0);
2795     descr.width     = cx;
2796     descr.height    = cy;
2797     descr.useShm    = FALSE;
2798
2799     EnterCriticalSection( &X11DRV_CritSection );
2800     result = CALL_LARGE_STACK( X11DRV_DIB_SetImageBits, &descr );
2801     LeaveCriticalSection( &X11DRV_CritSection );
2802
2803     if (descr.infoBpp <= 8)
2804        HeapFree(GetProcessHeap(), 0, descr.colorMap);
2805     return result;
2806 }
2807
2808 /***********************************************************************
2809  *           X11DRV_DIB_SetDIBits
2810  */
2811 INT X11DRV_DIB_SetDIBits(
2812   BITMAPOBJ *bmp, DC *dc, UINT startscan,
2813   UINT lines, LPCVOID bits, const BITMAPINFO *info,
2814   UINT coloruse, HBITMAP hbitmap)
2815 {
2816   X11DRV_DIB_IMAGEBITS_DESCR descr;
2817   int height, tmpheight;
2818   INT result;
2819
2820   descr.dc = dc;
2821
2822   if (DIB_GetBitmapInfo( &info->bmiHeader, &descr.infoWidth, &height,
2823                          &descr.infoBpp, &descr.compression ) == -1)
2824       return 0;
2825
2826   tmpheight = height;
2827   if (height < 0) height = -height;
2828   if (!lines || (startscan >= height))
2829       return 0;
2830
2831   if (startscan + lines > height) lines = height - startscan;
2832
2833   switch (descr.infoBpp)
2834   {
2835        case 1:
2836        case 4:
2837        case 8:
2838                descr.colorMap = (RGBQUAD *)X11DRV_DIB_BuildColorMap(
2839                         coloruse == DIB_PAL_COLORS ? descr.dc : NULL, coloruse,
2840                                                           bmp->bitmap.bmBitsPixel,
2841                                                           info, &descr.nColorMap );
2842                if (!descr.colorMap) return 0;
2843                descr.rMask = descr.gMask = descr.bMask = 0;
2844                break;
2845        case 15:
2846        case 16:
2847                descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors : 0x7c00;
2848                descr.gMask = (descr.compression == BI_BITFIELDS) ?  *((DWORD *)info->bmiColors + 1) : 0x03e0;
2849                descr.bMask = (descr.compression == BI_BITFIELDS) ?  *((DWORD *)info->bmiColors + 2) : 0x001f;
2850                descr.colorMap = 0;
2851                break;
2852
2853        case 24:
2854                descr.rMask = descr.gMask = descr.bMask = 0;
2855                descr.colorMap = 0;
2856                break;
2857
2858        case 32:
2859                descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors : 0xff0000;
2860                descr.gMask = (descr.compression == BI_BITFIELDS) ?  *((DWORD *)info->bmiColors + 1) : 0xff00;
2861                descr.bMask = (descr.compression == BI_BITFIELDS) ?  *((DWORD *)info->bmiColors + 2) : 0xff;
2862                descr.colorMap = 0;
2863                break;
2864
2865        default: break;
2866   }
2867
2868   /* HACK for now */
2869   if(!bmp->physBitmap)
2870     X11DRV_CreateBitmap(hbitmap);
2871
2872   descr.bits      = bits;
2873   descr.image     = NULL;
2874   descr.palentry  = NULL;
2875   descr.lines     = tmpheight >= 0 ? lines : -lines;
2876   descr.depth     = bmp->bitmap.bmBitsPixel;
2877   descr.drawable  = (Pixmap)bmp->physBitmap;
2878   descr.gc        = BITMAP_GC(bmp);
2879   descr.xSrc      = 0;
2880   descr.ySrc      = 0;
2881   descr.xDest     = 0;
2882   descr.yDest     = height - startscan - lines;
2883   descr.width     = bmp->bitmap.bmWidth;
2884   descr.height    = lines;
2885   descr.useShm    = FALSE;
2886
2887   EnterCriticalSection( &X11DRV_CritSection );
2888   result = CALL_LARGE_STACK( X11DRV_DIB_SetImageBits, &descr );
2889   LeaveCriticalSection( &X11DRV_CritSection );
2890
2891   if (descr.colorMap) HeapFree(GetProcessHeap(), 0, descr.colorMap);
2892
2893   return result;
2894 }
2895
2896 /***********************************************************************
2897  *           X11DRV_DIB_GetDIBits
2898  */
2899 INT X11DRV_DIB_GetDIBits(
2900   BITMAPOBJ *bmp, DC *dc, UINT startscan,
2901   UINT lines, LPVOID bits, BITMAPINFO *info,
2902   UINT coloruse, HBITMAP hbitmap)
2903 {
2904   X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *) bmp->dib;
2905   X11DRV_DIB_IMAGEBITS_DESCR descr;
2906   PALETTEOBJ * palette;
2907
2908   TRACE("%u scanlines of (%i,%i) -> (%i,%i) starting from %u\n",
2909         lines, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
2910         (int)info->bmiHeader.biWidth, (int)info->bmiHeader.biHeight,
2911         startscan );
2912
2913   if (!(palette = (PALETTEOBJ*)GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC )))
2914       return 0;
2915
2916   if( lines > info->bmiHeader.biHeight )  lines = info->bmiHeader.biHeight;
2917   /* Top-down images have a negative biHeight, the scanlines of theses images
2918    * were inverted in X11DRV_DIB_GetImageBits_xx
2919    * To prevent this we simply change the sign of lines
2920    * (the number of scan lines to copy).
2921    * Negative lines are correctly handled by X11DRV_DIB_GetImageBits_xx.
2922    */
2923   if( info->bmiHeader.biHeight < 0 && lines > 0) lines = -lines;
2924
2925   if( startscan >= bmp->bitmap.bmHeight ) return FALSE;
2926
2927   if (DIB_GetBitmapInfo( &info->bmiHeader, &descr.infoWidth, &descr.lines,
2928                         &descr.infoBpp, &descr.compression ) == -1)
2929       return FALSE;
2930
2931   switch (descr.infoBpp)
2932   {
2933       case 1:
2934       case 4:
2935       case 8:
2936       case 24:
2937           descr.rMask = descr.gMask = descr.bMask = 0;
2938           break;
2939       case 15:
2940       case 16:
2941           descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors : 0x7c00;
2942           descr.gMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 1) : 0x03e0;
2943           descr.bMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 2) : 0x001f;
2944           break;
2945
2946       case 32:
2947           descr.rMask = (descr.compression == BI_BITFIELDS) ? *(DWORD *)info->bmiColors : 0xff0000;
2948           descr.gMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 1) : 0xff00;
2949           descr.bMask = (descr.compression == BI_BITFIELDS) ? *((DWORD *)info->bmiColors + 2) : 0xff;
2950           break;
2951   }
2952
2953   /* Hack for now */
2954   if(!bmp->physBitmap)
2955     X11DRV_CreateBitmap(hbitmap);
2956
2957
2958   descr.dc        = dc;
2959   descr.palentry  = palette->logpalette.palPalEntry;
2960   descr.bits      = bits;
2961   descr.lines     = lines;
2962   descr.depth     = bmp->bitmap.bmBitsPixel;
2963   descr.drawable  = (Pixmap)bmp->physBitmap;
2964   descr.gc        = BITMAP_GC(bmp);
2965   descr.xSrc      = 0;
2966   descr.ySrc      = startscan;
2967   descr.xDest     = 0;
2968   descr.yDest     = 0;
2969   descr.width     = bmp->bitmap.bmWidth;
2970   descr.height    = bmp->bitmap.bmHeight;
2971   descr.colorMap  = info->bmiColors;
2972
2973   if (dib)
2974     descr.useShm = (dib->shminfo.shmid != -1);
2975   else
2976     descr.useShm = FALSE;
2977
2978   EnterCriticalSection( &X11DRV_CritSection );
2979
2980   descr.image  = (XImage *)CALL_LARGE_STACK( X11DRV_BITMAP_GetXImage, bmp );
2981   CALL_LARGE_STACK( X11DRV_DIB_GetImageBits, &descr );
2982
2983   LeaveCriticalSection( &X11DRV_CritSection );
2984
2985   if(info->bmiHeader.biSizeImage == 0) /* Fill in biSizeImage */
2986       info->bmiHeader.biSizeImage = DIB_GetDIBImageBytes(
2987                                          info->bmiHeader.biWidth,
2988                                          info->bmiHeader.biHeight,
2989                                          info->bmiHeader.biBitCount );
2990
2991   info->bmiHeader.biCompression = 0;
2992
2993   GDI_HEAP_UNLOCK( dc->w.hPalette );
2994
2995   return lines;
2996 }
2997
2998 /***********************************************************************
2999  *           DIB_DoProtectDIBSection
3000  */
3001 static void X11DRV_DIB_DoProtectDIBSection( BITMAPOBJ *bmp, DWORD new_prot )
3002 {
3003     DIBSECTION *dib = bmp->dib;
3004     INT effHeight = dib->dsBm.bmHeight >= 0? dib->dsBm.bmHeight
3005                                              : -dib->dsBm.bmHeight;
3006     INT totalSize = dib->dsBmih.biSizeImage? dib->dsBmih.biSizeImage
3007                          : dib->dsBm.bmWidthBytes * effHeight;
3008     DWORD old_prot;
3009
3010     VirtualProtect(dib->dsBm.bmBits, totalSize, new_prot, &old_prot);
3011     TRACE("Changed protection from %ld to %ld\n", old_prot, new_prot);
3012 }
3013
3014 /***********************************************************************
3015  *           X11DRV_DIB_DoUpdateDIBSection
3016  */
3017 static void X11DRV_DIB_DoUpdateDIBSection(BITMAPOBJ *bmp, BOOL toDIB)
3018 {
3019   X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *) bmp->dib;
3020   X11DRV_DIB_IMAGEBITS_DESCR descr;
3021
3022   if (DIB_GetBitmapInfo( &dib->dibSection.dsBmih, &descr.infoWidth, &descr.lines,
3023                          &descr.infoBpp, &descr.compression ) == -1)
3024     return;
3025
3026   descr.dc        = NULL;
3027   descr.palentry  = NULL;
3028   descr.image     = dib->image;
3029   descr.colorMap  = (RGBQUAD *)dib->colorMap;
3030   descr.nColorMap = dib->nColorMap;
3031   descr.bits      = dib->dibSection.dsBm.bmBits;
3032   descr.depth     = bmp->bitmap.bmBitsPixel;
3033
3034   switch (descr.infoBpp)
3035   {
3036     case 1:
3037     case 4:
3038     case 8:
3039     case 24:
3040       descr.rMask = descr.gMask = descr.bMask = 0;
3041       break;
3042     case 15:
3043     case 16:
3044       descr.rMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[0] : 0x7c00;
3045       descr.gMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[1] : 0x03e0;
3046       descr.bMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[2] : 0x001f;
3047       break;
3048
3049     case 32:
3050       descr.rMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[0] : 0xff;
3051       descr.gMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[1] : 0xff00;
3052       descr.bMask = (descr.compression == BI_BITFIELDS) ? dib->dibSection.dsBitfields[2] : 0xff0000;
3053       break;
3054   }
3055
3056   /* Hack for now */
3057   descr.drawable  = (Pixmap)bmp->physBitmap;
3058   descr.gc        = BITMAP_GC(bmp);
3059   descr.xSrc      = 0;
3060   descr.ySrc      = 0;
3061   descr.xDest     = 0;
3062   descr.yDest     = 0;
3063   descr.width     = bmp->bitmap.bmWidth;
3064   descr.height    = bmp->bitmap.bmHeight;
3065   descr.useShm = (dib->shminfo.shmid != -1);
3066
3067   if (toDIB)
3068     {
3069       TRACE("Copying from Pixmap to DIB bits\n");
3070       EnterCriticalSection( &X11DRV_CritSection );
3071       CALL_LARGE_STACK( X11DRV_DIB_GetImageBits, &descr );
3072       LeaveCriticalSection( &X11DRV_CritSection );
3073     }
3074   else
3075     {
3076       TRACE("Copying from DIB bits to Pixmap\n");
3077       EnterCriticalSection( &X11DRV_CritSection );
3078       CALL_LARGE_STACK( X11DRV_DIB_SetImageBits, &descr );
3079       LeaveCriticalSection( &X11DRV_CritSection );
3080     }
3081 }
3082
3083 /***********************************************************************
3084  *           X11DRV_DIB_FaultHandler
3085  */
3086 static BOOL X11DRV_DIB_FaultHandler( LPVOID res, LPCVOID addr )
3087 {
3088   BOOL handled = FALSE;
3089   BITMAPOBJ *bmp;
3090
3091   bmp = (BITMAPOBJ *)GDI_GetObjPtr( (HBITMAP)res, BITMAP_MAGIC );
3092   if (!bmp) return FALSE;
3093
3094   if (bmp->dib)
3095     switch (((X11DRV_DIBSECTION *) bmp->dib)->status)
3096       {
3097       case X11DRV_DIB_GdiMod:
3098         TRACE("called in status DIB_GdiMod\n" );
3099         X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READWRITE );
3100         X11DRV_DIB_DoUpdateDIBSection( bmp, TRUE );
3101         X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READONLY );
3102         ((X11DRV_DIBSECTION *) bmp->dib)->status = X11DRV_DIB_InSync;
3103         handled = TRUE;
3104         break;
3105
3106       case X11DRV_DIB_InSync:
3107         TRACE("called in status X11DRV_DIB_InSync\n" );
3108         X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READWRITE );
3109         ((X11DRV_DIBSECTION *) bmp->dib)->status = X11DRV_DIB_AppMod;
3110         handled = TRUE;
3111         break;
3112
3113       case X11DRV_DIB_AppMod:
3114         FIXME("called in status X11DRV_DIB_AppMod: this can't happen!\n" );
3115         break;
3116
3117       case X11DRV_DIB_NoHandler:
3118         FIXME("called in status DIB_NoHandler: this can't happen!\n" );
3119         break;
3120       }
3121
3122   GDI_HEAP_UNLOCK( (HBITMAP)res );
3123   return handled;
3124 }
3125
3126 /***********************************************************************
3127  *           X11DRV_DIB_UpdateDIBSection
3128  */
3129 void X11DRV_DIB_UpdateDIBSection(DC *dc, BOOL toDIB)
3130 {
3131   BITMAPOBJ *bmp;
3132
3133   /* Ensure this is a Compatible DC that has a DIB section selected */
3134
3135   if (!dc) return;
3136   if (!(dc->w.flags & DC_MEMORY)) return;
3137
3138   bmp = (BITMAPOBJ *)GDI_GetObjPtr( dc->w.hBitmap, BITMAP_MAGIC );
3139   if (!bmp) return;
3140
3141   if (!bmp->dib)
3142     {
3143       GDI_HEAP_UNLOCK(dc->w.hBitmap);
3144       return;
3145     }
3146
3147   if (!toDIB)
3148     {
3149       /* Prepare for access to the DIB by GDI functions */
3150
3151       switch (((X11DRV_DIBSECTION *) bmp->dib)->status)
3152         {
3153         default:
3154         case X11DRV_DIB_NoHandler:
3155           X11DRV_DIB_DoUpdateDIBSection( bmp, FALSE );
3156           break;
3157
3158         case X11DRV_DIB_GdiMod:
3159           TRACE("fromDIB called in status X11DRV_DIB_GdiMod\n" );
3160           /* nothing to do */
3161           break;
3162
3163         case X11DRV_DIB_InSync:
3164           TRACE("fromDIB called in status X11DRV_DIB_InSync\n" );
3165           /* nothing to do */
3166           break;
3167
3168         case X11DRV_DIB_AppMod:
3169           TRACE("fromDIB called in status X11DRV_DIB_AppMod\n" );
3170           X11DRV_DIB_DoUpdateDIBSection( bmp, FALSE );
3171           X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READONLY );
3172           ((X11DRV_DIBSECTION *) bmp->dib)->status = X11DRV_DIB_InSync;
3173           break;
3174         }
3175     }
3176   else
3177     {
3178       /* Acknowledge write access to the DIB by GDI functions */
3179
3180       switch (((X11DRV_DIBSECTION *) bmp->dib)->status)
3181         {
3182         default:
3183         case X11DRV_DIB_NoHandler:
3184           X11DRV_DIB_DoUpdateDIBSection( bmp, TRUE );
3185           break;
3186
3187         case X11DRV_DIB_GdiMod:
3188           TRACE("  toDIB called in status X11DRV_DIB_GdiMod\n" );
3189           /* nothing to do */
3190           break;
3191
3192         case X11DRV_DIB_InSync:
3193           TRACE("  toDIB called in status X11DRV_DIB_InSync\n" );
3194           X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_NOACCESS );
3195           ((X11DRV_DIBSECTION *) bmp->dib)->status = X11DRV_DIB_GdiMod;
3196           break;
3197
3198         case X11DRV_DIB_AppMod:
3199           FIXME("  toDIB called in status X11DRV_DIB_AppMod: "
3200                 "this can't happen!\n" );
3201           break;
3202         }
3203     }
3204
3205     GDI_HEAP_UNLOCK(dc->w.hBitmap);
3206 }
3207
3208 /***********************************************************************
3209  *           X11DRV_DIB_CreateDIBSection16
3210  */
3211 HBITMAP16 X11DRV_DIB_CreateDIBSection16(
3212   DC *dc, BITMAPINFO *bmi, UINT16 usage,
3213   SEGPTR *bits, HANDLE section,
3214   DWORD offset, DWORD ovr_pitch)
3215 {
3216   HBITMAP res = X11DRV_DIB_CreateDIBSection(dc, bmi, usage, NULL,
3217                                             section, offset, ovr_pitch);
3218   if ( res )
3219     {
3220       BITMAPOBJ *bmp = (BITMAPOBJ *) GDI_GetObjPtr(res, BITMAP_MAGIC);
3221       if ( bmp && bmp->dib )
3222         {
3223           DIBSECTION *dib = bmp->dib;
3224           INT height = dib->dsBm.bmHeight >= 0 ?
3225             dib->dsBm.bmHeight : -dib->dsBm.bmHeight;
3226           INT size = dib->dsBmih.biSizeImage ?
3227             dib->dsBmih.biSizeImage : dib->dsBm.bmWidthBytes * height;
3228           if ( dib->dsBm.bmBits )
3229             {
3230               ((X11DRV_DIBSECTION *) bmp->dib)->selector =
3231                 SELECTOR_AllocBlock( dib->dsBm.bmBits, size,
3232                                      SEGMENT_DATA, FALSE, FALSE );
3233             }
3234           TRACE("ptr = %p, size =%d, selector = %04x, segptr = %ld\n",
3235                          dib->dsBm.bmBits, size, ((X11DRV_DIBSECTION *) bmp->dib)->selector,
3236                          PTR_SEG_OFF_TO_SEGPTR(((X11DRV_DIBSECTION *) bmp->dib)->selector, 0));
3237         }
3238       GDI_HEAP_UNLOCK( res );
3239
3240       if ( bits )
3241         *bits = PTR_SEG_OFF_TO_SEGPTR( ((X11DRV_DIBSECTION *) bmp->dib)->selector, 0 );
3242     }
3243
3244     return res;
3245 }
3246
3247 /***********************************************************************
3248  *           X11DRV_XShmErrorHandler
3249  *
3250  */
3251 static int XShmErrorHandler(Display *dpy, XErrorEvent *event)
3252 {
3253     XShmErrorFlag = 1;
3254     return 0;
3255 }
3256
3257 /***********************************************************************
3258  *           X11DRV_XShmCreateImage
3259  *
3260  */
3261
3262 extern BOOL X11DRV_XShmCreateImage(XImage** image, int width, int height, int bpp,
3263                                                    XShmSegmentInfo* shminfo)
3264 {
3265     int (*WineXHandler)(Display *, XErrorEvent *);
3266
3267     *image = TSXShmCreateImage(display, X11DRV_GetVisual(), bpp, ZPixmap, NULL, shminfo, width, height);
3268     if( *image != NULL )
3269     {
3270         EnterCriticalSection( &X11DRV_CritSection );
3271         shminfo->shmid = shmget(IPC_PRIVATE, (*image)->bytes_per_line * height,
3272                                   IPC_CREAT|0700);
3273         if( shminfo->shmid != -1 )
3274         {
3275             shminfo->shmaddr = (*image)->data = shmat(shminfo->shmid, 0, 0);
3276             if( shminfo->shmaddr != (char*)-1 )
3277             {
3278                 shminfo->readOnly = FALSE;
3279                 if( TSXShmAttach( display, shminfo ) != 0)
3280                 {
3281                   /* Reset the error flag */
3282                     XShmErrorFlag = 0;
3283                     WineXHandler = XSetErrorHandler(XShmErrorHandler);
3284                     XSync( display, 0 );
3285
3286                     if (!XShmErrorFlag)
3287                     {
3288                         shmctl(shminfo->shmid, IPC_RMID, 0);
3289
3290                         XSetErrorHandler(WineXHandler);
3291                         LeaveCriticalSection( &X11DRV_CritSection );
3292
3293                         return TRUE; /* Success! */
3294                     }
3295                     /* An error occured */
3296                     XShmErrorFlag = 0;
3297                     XSetErrorHandler(WineXHandler);
3298                 }
3299                 shmdt(shminfo->shmaddr);
3300             }
3301             shmctl(shminfo->shmid, IPC_RMID, 0);
3302         }
3303         XFlush(display);
3304         XDestroyImage(*image);
3305         LeaveCriticalSection( &X11DRV_CritSection );
3306     }
3307     return FALSE;
3308 }
3309
3310
3311
3312
3313 /***********************************************************************
3314  *           X11DRV_DIB_CreateDIBSection
3315  */
3316 HBITMAP X11DRV_DIB_CreateDIBSection(
3317   DC *dc, BITMAPINFO *bmi, UINT usage,
3318   LPVOID *bits, HANDLE section,
3319   DWORD offset, DWORD ovr_pitch)
3320 {
3321   HBITMAP res = 0;
3322   BITMAPOBJ *bmp = NULL;
3323   X11DRV_DIBSECTION *dib = NULL;
3324   int *colorMap = NULL;
3325   int nColorMap;
3326
3327   /* Fill BITMAP32 structure with DIB data */
3328   BITMAPINFOHEADER *bi = &bmi->bmiHeader;
3329   INT effHeight, totalSize;
3330   BITMAP bm;
3331
3332   TRACE("format (%ld,%ld), planes %d, bpp %d, size %ld, colors %ld (%s)\n",
3333         bi->biWidth, bi->biHeight, bi->biPlanes, bi->biBitCount,
3334         bi->biSizeImage, bi->biClrUsed, usage == DIB_PAL_COLORS? "PAL" : "RGB");
3335
3336   effHeight = bi->biHeight >= 0 ? bi->biHeight : -bi->biHeight;
3337   bm.bmType = 0;
3338   bm.bmWidth = bi->biWidth;
3339   bm.bmHeight = effHeight;
3340   bm.bmWidthBytes = ovr_pitch ? ovr_pitch
3341                               : DIB_GetDIBWidthBytes(bm.bmWidth, bi->biBitCount);
3342   bm.bmPlanes = bi->biPlanes;
3343   bm.bmBitsPixel = bi->biBitCount;
3344   bm.bmBits = NULL;
3345
3346   /* Get storage location for DIB bits */
3347   totalSize = bi->biSizeImage? bi->biSizeImage : bm.bmWidthBytes * effHeight;
3348
3349   if (section)
3350     bm.bmBits = MapViewOfFile(section, FILE_MAP_ALL_ACCESS,
3351                               0L, offset, totalSize);
3352   else if (ovr_pitch && offset)
3353     bm.bmBits = (LPVOID) offset;
3354   else {
3355     offset = 0;
3356     bm.bmBits = VirtualAlloc(NULL, totalSize,
3357                              MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE);
3358   }
3359
3360   /* Create Color Map */
3361   if (bm.bmBits && bm.bmBitsPixel <= 8)
3362       colorMap = X11DRV_DIB_BuildColorMap( usage == DIB_PAL_COLORS? dc : NULL,
3363                                 usage, bm.bmBitsPixel, bmi, &nColorMap );
3364
3365   /* Allocate Memory for DIB and fill structure */
3366   if (bm.bmBits)
3367     dib = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(X11DRV_DIBSECTION));
3368   if (dib)
3369     {
3370       dib->dibSection.dsBm = bm;
3371       dib->dibSection.dsBmih = *bi;
3372
3373       /* Set dsBitfields values */
3374        if ( usage == DIB_PAL_COLORS || bi->biBitCount <= 8)
3375        {
3376            dib->dibSection.dsBitfields[0] = dib->dibSection.dsBitfields[1] = dib->dibSection.dsBitfields[2] = 0;
3377        }
3378        else switch( bi->biBitCount )
3379        {
3380            case 16:
3381                dib->dibSection.dsBitfields[0] = (bi->biCompression == BI_BITFIELDS) ? *(DWORD *)bmi->bmiColors : 0x7c00;
3382                dib->dibSection.dsBitfields[1] = (bi->biCompression == BI_BITFIELDS) ? *((DWORD *)bmi->bmiColors + 1) : 0x03e0;
3383                dib->dibSection.dsBitfields[2] = (bi->biCompression == BI_BITFIELDS) ? *((DWORD *)bmi->bmiColors + 2) : 0x001f;
3384                break;
3385
3386            case 24:
3387                dib->dibSection.dsBitfields[0] = 0xff;
3388                dib->dibSection.dsBitfields[1] = 0xff00;
3389                dib->dibSection.dsBitfields[2] = 0xff0000;
3390                break;
3391
3392            case 32:
3393                dib->dibSection.dsBitfields[0] = (bi->biCompression == BI_BITFIELDS) ? *(DWORD *)bmi->bmiColors : 0xff;
3394                dib->dibSection.dsBitfields[1] = (bi->biCompression == BI_BITFIELDS) ? *((DWORD *)bmi->bmiColors + 1) : 0xff00;
3395                dib->dibSection.dsBitfields[2] = (bi->biCompression == BI_BITFIELDS) ? *((DWORD *)bmi->bmiColors + 2) : 0xff0000;
3396                break;
3397        }
3398       dib->dibSection.dshSection = section;
3399       dib->dibSection.dsOffset = offset;
3400
3401       dib->status    = X11DRV_DIB_NoHandler;
3402       dib->selector  = 0;
3403
3404       dib->nColorMap = nColorMap;
3405       dib->colorMap  = colorMap;
3406     }
3407
3408   /* Create Device Dependent Bitmap and add DIB pointer */
3409   if (dib)
3410     {
3411       res = CreateDIBitmap(dc->hSelf, bi, 0, NULL, bmi, usage);
3412       if (res)
3413         {
3414           bmp = (BITMAPOBJ *) GDI_GetObjPtr(res, BITMAP_MAGIC);
3415           if (bmp)
3416             {
3417               bmp->dib = (DIBSECTION *) dib;
3418               /* HACK for now */
3419               if(!bmp->physBitmap)
3420                 X11DRV_CreateBitmap(res);
3421             }
3422         }
3423     }
3424
3425   /* Create XImage */
3426   if (dib && bmp)
3427   {
3428       if (TSXShmQueryExtension(display) &&
3429           X11DRV_XShmCreateImage( &dib->image, bm.bmWidth, effHeight,
3430                                   bmp->bitmap.bmBitsPixel, &dib->shminfo ) )
3431       {
3432         ; /* Created Image */
3433       } else {
3434           XCREATEIMAGE( dib->image, bm.bmWidth, effHeight, bmp->bitmap.bmBitsPixel );
3435           dib->shminfo.shmid = -1;
3436       }
3437   }
3438
3439   /* Clean up in case of errors */
3440   if (!res || !bmp || !dib || !bm.bmBits || (bm.bmBitsPixel <= 8 && !colorMap))
3441     {
3442       TRACE("got an error res=%08x, bmp=%p, dib=%p, bm.bmBits=%p\n",
3443             res, bmp, dib, bm.bmBits);
3444       if (bm.bmBits)
3445         {
3446           if (section)
3447             UnmapViewOfFile(bm.bmBits), bm.bmBits = NULL;
3448           else if (!offset)
3449             VirtualFree(bm.bmBits, 0L, MEM_RELEASE), bm.bmBits = NULL;
3450         }
3451
3452       if (dib && dib->image) { XDestroyImage(dib->image); dib->image = NULL; }
3453       if (colorMap) { HeapFree(GetProcessHeap(), 0, colorMap); colorMap = NULL; }
3454       if (dib) { HeapFree(GetProcessHeap(), 0, dib); dib = NULL; }
3455       if (res) { DeleteObject(res); res = 0; }
3456     }
3457
3458   /* Install fault handler, if possible */
3459   if (bm.bmBits)
3460     {
3461       if (VIRTUAL_SetFaultHandler(bm.bmBits, X11DRV_DIB_FaultHandler, (LPVOID)res))
3462         {
3463           if (section || offset)
3464             {
3465               X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READWRITE );
3466               if (dib) dib->status = X11DRV_DIB_AppMod;
3467             }
3468           else
3469             {
3470               X11DRV_DIB_DoProtectDIBSection( bmp, PAGE_READONLY );
3471               if (dib) dib->status = X11DRV_DIB_InSync;
3472             }
3473         }
3474     }
3475
3476   /* Return BITMAP handle and storage location */
3477   if (res) GDI_HEAP_UNLOCK(res);
3478   if (bm.bmBits && bits) *bits = bm.bmBits;
3479   return res;
3480 }
3481
3482 /***********************************************************************
3483  *           X11DRV_DIB_DeleteDIBSection
3484  */
3485 void X11DRV_DIB_DeleteDIBSection(BITMAPOBJ *bmp)
3486 {
3487   X11DRV_DIBSECTION *dib = (X11DRV_DIBSECTION *) bmp->dib;
3488
3489   if (dib->image)
3490   {
3491       if (dib->shminfo.shmid != -1)
3492       {
3493           TSXShmDetach (display, &(dib->shminfo));
3494           XDestroyImage (dib->image);
3495           shmdt (dib->shminfo.shmaddr);
3496           dib->shminfo.shmid = -1;
3497       }
3498       else
3499           XDestroyImage( dib->image );
3500   }
3501
3502   if (dib->colorMap)
3503     HeapFree(GetProcessHeap(), 0, dib->colorMap);
3504
3505   if (dib->selector)
3506     {
3507       WORD count = (GET_SEL_LIMIT( dib->selector ) >> 16) + 1;
3508       SELECTOR_FreeBlock( dib->selector, count );
3509     }
3510 }
3511
3512
3513 /**************************************************************************
3514  *              X11DRV_DIB_CreateDIBFromPixmap
3515  *
3516  *  Allocates a packed DIB and copies the Pixmap data into it.
3517  *  If bDeletePixmap is TRUE, the Pixmap passed in is deleted after the conversion.
3518  */
3519 HGLOBAL X11DRV_DIB_CreateDIBFromPixmap(Pixmap pixmap, HDC hdc, BOOL bDeletePixmap)
3520 {
3521     HBITMAP hBmp = 0;
3522     BITMAPOBJ *pBmp = NULL;
3523     HGLOBAL hPackedDIB = 0;
3524
3525     /* Allocates an HBITMAP which references the Pixmap passed to us */
3526     hBmp = X11DRV_BITMAP_CreateBitmapHeaderFromPixmap(pixmap);
3527     if (!hBmp)
3528     {
3529         TRACE("\tCould not create bitmap header for Pixmap\n");
3530         goto END;
3531     }
3532
3533     /*
3534      * Create a packed DIB from the Pixmap wrapper bitmap created above.
3535      * A packed DIB contains a BITMAPINFO structure followed immediately by
3536      * an optional color palette and the pixel data.
3537      */
3538     hPackedDIB = DIB_CreateDIBFromBitmap(hdc, hBmp);
3539
3540     /* Get a pointer to the BITMAPOBJ structure */
3541     pBmp = (BITMAPOBJ *)GDI_GetObjPtr( hBmp, BITMAP_MAGIC );
3542
3543     /* We can now get rid of the HBITMAP wrapper we created earlier.
3544      * Note: Simply calling DeleteObject will free the embedded Pixmap as well.
3545      */
3546     if (!bDeletePixmap)
3547     {
3548         /* Clear the physBitmap to prevent the Pixmap from being deleted by DeleteObject */
3549         pBmp->physBitmap = NULL;
3550         pBmp->funcs = NULL;
3551     }
3552     DeleteObject(hBmp);
3553
3554 END:
3555     TRACE("\tReturning packed DIB %x\n", hPackedDIB);
3556     return hPackedDIB;
3557 }
3558
3559
3560 /**************************************************************************
3561  *                 X11DRV_DIB_CreatePixmapFromDIB
3562  *
3563  *    Creates a Pixmap from a packed DIB
3564  */
3565 Pixmap X11DRV_DIB_CreatePixmapFromDIB( HGLOBAL hPackedDIB, HDC hdc )
3566 {
3567     Pixmap pixmap = None;
3568     HBITMAP hBmp = 0;
3569     BITMAPOBJ *pBmp = NULL;
3570     LPBYTE pPackedDIB = NULL;
3571     LPBITMAPINFO pbmi = NULL;
3572     LPBITMAPINFOHEADER pbmiHeader = NULL;
3573     LPBYTE pbits = NULL;
3574
3575     /* Get a pointer to the packed DIB's data  */
3576     pPackedDIB = (LPBYTE)GlobalLock(hPackedDIB);
3577     pbmiHeader = (LPBITMAPINFOHEADER)pPackedDIB;
3578     pbmi = (LPBITMAPINFO)pPackedDIB;
3579     pbits = (LPBYTE)(pPackedDIB
3580                      + DIB_BitmapInfoSize( (LPBITMAPINFO)pbmiHeader, DIB_RGB_COLORS ));
3581
3582     /* Create a DDB from the DIB */
3583
3584     hBmp = CreateDIBitmap(hdc,
3585                           pbmiHeader,
3586                           CBM_INIT,
3587                           (LPVOID)pbits,
3588                           pbmi,
3589                           DIB_RGB_COLORS);
3590
3591     GlobalUnlock(hPackedDIB);
3592
3593     TRACE("CreateDIBitmap returned %x\n", hBmp);
3594
3595     /* Retrieve the internal Pixmap from the DDB */
3596
3597     pBmp = (BITMAPOBJ *) GDI_GetObjPtr( hBmp, BITMAP_MAGIC );
3598
3599     pixmap = (Pixmap)pBmp->physBitmap;
3600     /* clear the physBitmap so that we can steal its pixmap */
3601     pBmp->physBitmap = NULL;
3602     pBmp->funcs = NULL;
3603
3604     /* Delete the DDB we created earlier now that we have stolen its pixmap */
3605     DeleteObject(hBmp);
3606
3607     TRACE("\tReturning Pixmap %ld\n", pixmap);
3608     return pixmap;
3609 }