objects/dib.c

   1 /*
   2  * GDI device-independent bitmaps
   3  *
   4  * Copyright 1993,1994  Alexandre Julliard
   5  */
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <X11/Xlib.h>
  10 #include <X11/Xutil.h>
  11 #include "dc.h"
  12 #include "bitmap.h"
  13 #include "callback.h"
  14 #include "palette.h"
  15 #include "stddebug.h"
  16 #include "color.h"
  17 #include "debug.h"
  18
  19 extern void CLIPPING_UpdateGCRegion(DC* );
  20
  21 /***********************************************************************
  22  *           DIB_GetImageWidthBytes
  23  *
  24  * Return the width of an X image in bytes
  25  */
  26 int DIB_GetImageWidthBytes( int width, int depth )
  27 {
  28     int words;
  29
  30     switch(depth)
  31     {
  32         case 1:  words = (width + 31) / 32; break;
  33         case 4:  words = (width + 7) / 8; break;
  34         case 8:  words = (width + 3) / 4; break;
  35         case 15:
  36         case 16: words = (width + 1) / 2; break;
  37         case 24: words = (width * 3 + 3)/4; break;
  38
  39         default:
  40                 fprintf(stderr, "DIB: unsupported depth %d.\n", depth );
  41         /* fall through */
  42         case 32:
  43                 words = width;
  44     }
  45     return 4 * words;
  46 }
  47
  48
  49 /***********************************************************************
  50  *           DIB_BitmapInfoSize
  51  *
  52  * Return the size of the bitmap info structure.
  53  */
  54 int DIB_BitmapInfoSize( BITMAPINFO * info, WORD coloruse )
  55 {
  56     int colors;
  57
  58     if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
  59     {
  60         BITMAPCOREHEADER *core = (BITMAPCOREHEADER *)info;
  61         colors = (core->bcBitCount != 24) ? 1 << core->bcBitCount : 0;
  62         return sizeof(BITMAPCOREHEADER) + colors *
  63              ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
  64     }
  65     else  /* assume BITMAPINFOHEADER */
  66     {
  67         colors = info->bmiHeader.biClrUsed;
  68         if (!colors && (info->bmiHeader.biBitCount != 24))
  69             colors = 1 << info->bmiHeader.biBitCount;
  70         return sizeof(BITMAPINFOHEADER) + colors *
  71                ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
  72     }
  73 }
  74
  75
  76 /***********************************************************************
  77  *           DIB_GetBitmapInfo
  78  *
  79  * Get the info from a bitmap header.
  80  * Return 1 for INFOHEADER, 0 for COREHEADER, -1 for error.
  81  */
  82 static int DIB_GetBitmapInfo( const BITMAPINFOHEADER *header, DWORD *width,
  83                               DWORD *height, WORD *bpp )
  84 {
  85     if (header->biSize == sizeof(BITMAPINFOHEADER))
  86     {
  87         *width  = header->biWidth;
  88         *height = header->biHeight;
  89         *bpp    = header->biBitCount;
  90         return 1;
  91     }
  92     if (header->biSize == sizeof(BITMAPCOREHEADER))
  93     {
  94         BITMAPCOREHEADER *core = (BITMAPCOREHEADER *)header;
  95         *width  = core->bcWidth;
  96         *height = core->bcHeight;
  97         *bpp    = core->bcBitCount;
  98         return 0;
  99     }
 100     fprintf( stderr, "DIB_GetBitmapInfo: wrong size (%ld) for header\n",
 101              header->biSize );
 102     return -1;
 103 }
 104
 105
 106 /***********************************************************************
 107  *           DIB_BuildColorMap
 108  *
 109  * Build the color map from the bitmap palette. Should not be called
 110  * for a 24-bit deep bitmap.
 111  */
 112 static int *DIB_BuildColorMap( DC *dc, WORD coloruse, WORD depth,
 113                                BITMAPINFO *info )
 114 {
 115     int i, colors;
 116     BOOL32 isInfo;
 117     WORD *colorPtr;
 118     int *colorMapping;
 119
 120     if ((isInfo = (info->bmiHeader.biSize == sizeof(BITMAPINFOHEADER))))
 121     {
 122         colors = info->bmiHeader.biClrUsed;
 123         if (!colors) colors = 1 << info->bmiHeader.biBitCount;
 124         colorPtr = (WORD *)info->bmiColors;
 125     }
 126     else  /* assume BITMAPCOREINFO */
 127     {
 128         colors = 1 << ((BITMAPCOREHEADER *)&info->bmiHeader)->bcBitCount;
 129         colorPtr = (WORD *)((BITMAPCOREINFO *)info)->bmciColors;
 130     }
 131     if (!(colorMapping = (int *)malloc( colors * sizeof(int) ))) return NULL;
 132
 133     if (coloruse == DIB_RGB_COLORS)
 134     {
 135         if (isInfo)
 136         {
 137             RGBQUAD * rgb = (RGBQUAD *)colorPtr;
 138
 139             if (depth == 1)  /* Monochrome */
 140                 for (i = 0; i < colors; i++, rgb++)
 141                     colorMapping[i] = (rgb->rgbRed + rgb->rgbGreen +
 142                                        rgb->rgbBlue > 255*3/2);
 143             else
 144                 for (i = 0; i < colors; i++, rgb++)
 145                     colorMapping[i] = COLOR_ToPhysical( dc, RGB(rgb->rgbRed,
 146                                                                 rgb->rgbGreen,
 147                                                                 rgb->rgbBlue));
 148         }
 149         else
 150         {
 151             RGBTRIPLE * rgb = (RGBTRIPLE *)colorPtr;
 152
 153             if (depth == 1)  /* Monochrome */
 154                 for (i = 0; i < colors; i++, rgb++)
 155                     colorMapping[i] = (rgb->rgbtRed + rgb->rgbtGreen +
 156                                        rgb->rgbtBlue > 255*3/2);
 157             else
 158                 for (i = 0; i < colors; i++, rgb++)
 159                     colorMapping[i] = COLOR_ToPhysical( dc, RGB(rgb->rgbtRed,
 160                                                                rgb->rgbtGreen,
 161                                                                rgb->rgbtBlue));
 162         }
 163     }
 164     else  /* DIB_PAL_COLORS */
 165     {
 166         for (i = 0; i < colors; i++, colorPtr++)
 167             colorMapping[i] = COLOR_ToPhysical( dc, PALETTEINDEX(*colorPtr) );
 168     }
 169     return colorMapping;
 170 }
 171
 172
 173 /***********************************************************************
 174  *           DIB_SetImageBits_1
 175  *
 176  * SetDIBits for a 1-bit deep DIB.
 177  */
 178 static void DIB_SetImageBits_1( DWORD lines, BYTE *bits, DWORD width,
 179                                 int *colors, XImage *bmpImage )
 180 {
 181     DWORD i, x;
 182     BYTE pad, pix;
 183
 184     if (!(width & 31)) pad = 0;
 185     else pad = ((32 - (width & 31)) + 7) / 8;
 186
 187     while (lines--)
 188     {
 189         for (i = width/8, x = 0; (i > 0); i--)
 190         {
 191             pix = *bits++;
 192             XPutPixel( bmpImage, x++, lines, colors[pix >> 7] );
 193             XPutPixel( bmpImage, x++, lines, colors[(pix >> 6) & 1] );
 194             XPutPixel( bmpImage, x++, lines, colors[(pix >> 5) & 1] );
 195             XPutPixel( bmpImage, x++, lines, colors[(pix >> 4) & 1] );
 196             XPutPixel( bmpImage, x++, lines, colors[(pix >> 3) & 1] );
 197             XPutPixel( bmpImage, x++, lines, colors[(pix >> 2) & 1] );
 198             XPutPixel( bmpImage, x++, lines, colors[(pix >> 1) & 1] );
 199             XPutPixel( bmpImage, x++, lines, colors[pix & 1] );
 200         }
 201         pix = *bits;
 202         switch(width & 7)
 203         {
 204         case 7: XPutPixel( bmpImage, x++, lines, colors[pix >> 7] ); pix <<= 1;
 205         case 6: XPutPixel( bmpImage, x++, lines, colors[pix >> 7] ); pix <<= 1;
 206         case 5: XPutPixel( bmpImage, x++, lines, colors[pix >> 7] ); pix <<= 1;
 207         case 4: XPutPixel( bmpImage, x++, lines, colors[pix >> 7] ); pix <<= 1;
 208         case 3: XPutPixel( bmpImage, x++, lines, colors[pix >> 7] ); pix <<= 1;
 209         case 2: XPutPixel( bmpImage, x++, lines, colors[pix >> 7] ); pix <<= 1;
 210         case 1: XPutPixel( bmpImage, x++, lines, colors[pix >> 7] );
 211         }
 212         bits += pad;
 213     }
 214 }
 215
 216
 217 /***********************************************************************
 218  *           DIB_SetImageBits_4
 219  *
 220  * SetDIBits for a 4-bit deep DIB.
 221  */
 222 static void DIB_SetImageBits_4( DWORD lines, BYTE *bits, DWORD width,
 223                                 int *colors, XImage *bmpImage )
 224 {
 225     DWORD i, x;
 226     BYTE pad;
 227
 228     if (!(width & 7)) pad = 0;
 229     else pad = ((8 - (width & 7)) + 1) / 2;
 230
 231     while (lines--)
 232     {
 233         for (i = width/2, x = 0; i > 0; i--)
 234         {
 235             BYTE pix = *bits++;
 236             XPutPixel( bmpImage, x++, lines, colors[pix >> 4] );
 237             XPutPixel( bmpImage, x++, lines, colors[pix & 0x0f] );
 238         }
 239         if (width & 1) XPutPixel( bmpImage, x, lines, colors[*bits >> 4] );
 240         bits += pad;
 241     }
 242 }
 243
 244 #define check_xy(x,y) \
 245         if (x > width) { \
 246                 x = 0; \
 247                 if (lines) \
 248                         lines--; \
 249         }
 250
 251 /***********************************************************************
 252  *           DIB_SetImageBits_RLE4
 253  *
 254  * SetDIBits for a 4-bit deep compressed DIB.
 255  */
 256 static void DIB_SetImageBits_RLE4( DWORD lines, BYTE *bits, DWORD width,
 257                                    int *colors, XImage *bmpImage )
 258 {
 259         int x = 0, c, length;
 260         BYTE *begin = bits;
 261
 262         lines--;
 263         while ((int)lines >= 0)
 264         {
 265                 length = *bits++;
 266                 if (length) {   /* encoded */
 267                         c = *bits++;
 268                         while (length--) {
 269                                 XPutPixel(bmpImage, x++, lines, colors[c >> 4]);
 270                                 check_xy(x, y);
 271                                 if (length) {
 272                                         length--;
 273                                         XPutPixel(bmpImage, x++, lines, colors[c & 0xf]);
 274                                         check_xy(x, y);
 275                                 }
 276                         }
 277                 } else {
 278                         length = *bits++;
 279                         switch (length) {
 280                                 case 0: /* eol */
 281                                         x = 0;
 282                                         lines--;
 283                                         continue;
 284
 285                                 case 1: /* eopicture */
 286                                         return;
 287
 288                                 case 2: /* delta */
 289                                         x += *bits++;
 290                                         lines -= *bits++;
 291                                         continue;
 292
 293                                 default: /* absolute */
 294                                         while (length--) {
 295                                                 c = *bits++;
 296                                                 XPutPixel(bmpImage, x++, lines, colors[c >> 4]);
 297                                                 check_xy(x, y);
 298                                                 if (length) {
 299                                                         length--;
 300                                                         XPutPixel(bmpImage, x++, lines, colors[c & 0xf]);
 301                                                         check_xy(x, y);
 302                                                 }
 303                                         }
 304                                         if ((bits - begin) & 1)
 305                                                 bits++;
 306                         }
 307                 }
 308         }
 309 }
 310
 311 /***********************************************************************
 312  *           DIB_SetImageBits_8
 313  *
 314  * SetDIBits for an 8-bit deep DIB.
 315  */
 316 static void DIB_SetImageBits_8( DWORD lines, BYTE *bits, DWORD width,
 317                                 int *colors, XImage *bmpImage )
 318 {
 319     DWORD x;
 320     BYTE pad = (4 - (width & 3)) & 3;
 321
 322     while (lines--)
 323     {
 324         for (x = 0; x < width; x++)
 325             XPutPixel( bmpImage, x, lines, colors[*bits++] );
 326         bits += pad;
 327     }
 328 }
 329
 330 /***********************************************************************
 331  *            DIB_SetImageBits_RLE8
 332  *
 333  * SetDIBits for an 8-bit deep compressed DIB.
 334  *
 335  * This function rewritten 941113 by James Youngman.  WINE blew out when I
 336  * first ran it because my desktop wallpaper is a (large) RLE8 bitmap.
 337  *
 338  * This was because the algorithm assumed that all RLE8 bitmaps end with the
 339  * 'End of bitmap' escape code.  This code is very much laxer in what it
 340  * allows to end the expansion.  Possibly too lax.  See the note by
 341  * case RleDelta.  BTW, MS's documentation implies that a correct RLE8
 342  * bitmap should end with RleEnd, but on the other hand, software exists
 343  * that produces ones that don't and Windows 3.1 doesn't complain a bit
 344  * about it.
 345  *
 346  * (No) apologies for my English spelling.  [Emacs users: c-indent-level=4].
 347  *                      James A. Youngman <mbcstjy@afs.man.ac.uk>
 348  *                                              [JAY]
 349  */
 350
 351 enum Rle8_EscapeCodes
 352 {
 353   /*
 354    * Apologies for polluting your file's namespace...
 355    */
 356   RleEol        = 0,            /* End of line */
 357   RleEnd        = 1,            /* End of bitmap */
 358   RleDelta      = 2             /* Delta */
 359 };
 360
 361 static void DIB_SetImageBits_RLE8( DWORD lines, BYTE *bits, DWORD width,
 362                                    int *colors, XImage *bmpImage )
 363 {
 364     int x;                      /* X-positon on each line.  Increases. */
 365     int line;                   /* Line #.  Starts at lines-1, decreases */
 366     BYTE *pIn = bits;           /* Pointer to current position in bits */
 367     BYTE length;                /* The length pf a run */
 368     BYTE color_index;           /* index into colors[] as read from bits */
 369     BYTE escape_code;           /* See enum Rle8_EscapeCodes.*/
 370     WORD color;                 /* value of colour[color_index] */
 371
 372     if (lines == 0)             /* Let's hope this doesn't happen. */
 373       return;
 374
 375     /*
 376      * Note that the bitmap data is stored by Windows starting at the
 377      * bottom line of the bitmap and going upwards.  Within each line,
 378      * the data is stored left-to-right.  That's the reason why line
 379      * goes from lines-1 to 0.                  [JAY]
 380      */
 381
 382     x = 0;
 383     line = lines-1;
 384     do
 385       {
 386           length = *pIn++;
 387
 388           /*
 389            * If the length byte is not zero (which is the escape value),
 390            * We have a run of length pixels all the same colour.  The colour
 391            * index is stored next.
 392            *
 393            * If the length byte is zero, we need to read the next byte to
 394            * know what to do.                   [JAY]
 395            */
 396           if (length != 0)
 397             {
 398                 /*
 399                  * [Run-Length] Encoded mode
 400                  */
 401                 color_index = (*pIn++); /* Get the colour index. */
 402                 color = colors[color_index];
 403
 404                 while(length--)
 405                   XPutPixel(bmpImage, x++, line, color);
 406             }
 407           else
 408             {
 409                 /*
 410                  * Escape codes (may be an absolute sequence though)
 411                  */
 412                 escape_code = (*pIn++);
 413                 switch(escape_code)
 414                   {
 415                     case RleEol: /* =0, end of line */
 416                       {
 417                           x = 0;
 418                           line--;
 419                           break;
 420                       }
 421
 422                     case RleEnd: /* =1, end of bitmap */
 423                       {
 424                           /*
 425                            * Not all RLE8 bitmaps end with this
 426                            * code.  For example, Paint Shop Pro
 427                            * produces some that don't.  That's (I think)
 428                            * what caused the previous implementation to
 429                            * fail.                      [JAY]
 430                            */
 431                           line=-1; /* Cause exit from do loop. */
 432                           break;
 433                       }
 434
 435                     case RleDelta: /* =2, a delta */
 436                       {
 437                           /*
 438                            * Note that deltaing to line 0
 439                            * will cause an exit from the loop,
 440                            * which may not be what is intended.
 441                            * The fact that there is a delta in the bits
 442                            * almost certainly implies that there is data
 443                            * to follow.  You may feel that we should
 444                            * jump to the top of the loop to avoid exiting
 445                            * in this case.
 446                            *
 447                            * TODO: Decide what to do here in that case. [JAY]
 448                            */
 449                           x     += (*pIn++);
 450                           line  -= (*pIn++);
 451                           if (line == 0)
 452                             {
 453                               dprintf_bitmap(stddeb,
 454                                              "DIB_SetImageBits_RLE8(): "
 455                                              "Delta to last line of bitmap "
 456                                              "(wrongly?) causes loop exit\n");
 457                             }
 458                           break;
 459                       }
 460
 461                     default:    /* >2, switch to absolute mode */
 462                       {
 463                           /*
 464                            * Absolute Mode
 465                            */
 466                           length = escape_code;
 467                           while(length--)
 468                             {
 469                                 color_index = (*pIn++);
 470                                 XPutPixel(bmpImage, x++, line,
 471                                           colors[color_index]);
 472                             }
 473
 474                           /*
 475                            * If you think for a moment you'll realise that the
 476                            * only time we could ever possibly read an odd
 477                            * number of bytes is when there is a 0x00 (escape),
 478                            * a value >0x02 (absolute mode) and then an odd-
 479                            * length run.  Therefore this is the only place we
 480                            * need to worry about it.  Everywhere else the
 481                            * bytes are always read in pairs.  [JAY]
 482                            */
 483                           if (escape_code & 1)
 484                             pIn++; /* Throw away the pad byte. */
 485                           break;
 486                       }
 487                   } /* switch (escape_code) : Escape sequence */
 488             }  /* process either an encoded sequence or an escape sequence */
 489
 490           /* We expect to come here more than once per line. */
 491       } while (line >= 0);  /* Do this until the bitmap is filled */
 492
 493     /*
 494      * Everybody comes here at the end.
 495      * Check how we exited the loop and print a message if it's a bit odd.
 496      *                                          [JAY]
 497      */
 498     if ( (*(pIn-2) != 0/*escape*/) || (*(pIn-1)!= RleEnd) )
 499       {
 500         dprintf_bitmap(stddeb, "DIB_SetImageBits_RLE8(): End-of-bitmap "
 501                        "without (strictly) proper escape code.  Last two "
 502                        "bytes were: %02X %02X.\n",
 503                        (int)*(pIn-2),
 504                        (int)*(pIn-1));
 505       }
 506 }
 507
 508
 509 /***********************************************************************
 510  *           DIB_SetImageBits_24
 511  *
 512  * SetDIBits for a 24-bit deep DIB.
 513  */
 514 static void DIB_SetImageBits_24( DWORD lines, BYTE *bits, DWORD width,
 515                                  DC *dc, XImage *bmpImage )
 516 {
 517     DWORD x;
 518     BYTE pad = (4 - ((width*3) & 3)) & 3;
 519
 520     /* "bits" order is reversed for some reason */
 521
 522     while (lines--)
 523     {
 524         for (x = 0; x < width; x++, bits += 3)
 525             XPutPixel( bmpImage, x, lines,
 526                        COLOR_ToPhysical(dc, RGB(bits[2],bits[1],bits[0])) );
 527
 528         bits += pad;
 529     }
 530 }
 531
 532
 533 /***********************************************************************
 534  *           DIB_SetImageBits
 535  *
 536  * Transfer the bits to an X image.
 537  * Helper function for SetDIBits() and SetDIBitsToDevice().
 538  */
 539 static int DIB_SetImageBits( DC *dc, DWORD lines, WORD depth, LPSTR bits,
 540                              DWORD infoWidth, WORD infoBpp,
 541                              BITMAPINFO *info, WORD coloruse,
 542                              Drawable drawable, GC gc, int xSrc, int ySrc,
 543                              int xDest, int yDest, int width, int height )
 544 {
 545     int *colorMapping;
 546     XImage *bmpImage;
 547     DWORD compression = 0;
 548
 549     if (info->bmiHeader.biSize == sizeof(BITMAPINFOHEADER))
 550         compression = info->bmiHeader.biCompression;
 551
 552       /* Build the color mapping table */
 553
 554     if (infoBpp == 24) colorMapping = NULL;
 555     else
 556         if (!(colorMapping = DIB_BuildColorMap( dc, coloruse, depth, info )))
 557             return 0;
 558
 559     if( dc->w.flags & DC_DIRTY ) CLIPPING_UpdateGCRegion(dc);
 560
 561       /* Transfer the pixels */
 562     XCREATEIMAGE(bmpImage, infoWidth, lines, depth );
 563
 564     switch(infoBpp)
 565     {
 566     case 1:
 567         DIB_SetImageBits_1( lines, bits, infoWidth,
 568                             colorMapping, bmpImage );
 569         break;
 570     case 4:
 571         if (compression) DIB_SetImageBits_RLE4( lines, bits, infoWidth,
 572                                                 colorMapping, bmpImage );
 573         else DIB_SetImageBits_4( lines, bits, infoWidth,
 574                                  colorMapping, bmpImage );
 575         break;
 576     case 8:
 577         if (compression) DIB_SetImageBits_RLE8( lines, bits, infoWidth,
 578                                                 colorMapping, bmpImage );
 579         else DIB_SetImageBits_8( lines, bits, infoWidth,
 580                                  colorMapping, bmpImage );
 581         break;
 582     case 24:
 583         DIB_SetImageBits_24( lines, bits, infoWidth, dc, bmpImage );
 584         break;
 585     default:
 586         fprintf( stderr, "Invalid depth %d for SetDIBits!\n", infoBpp );
 587         break;
 588     }
 589     if (colorMapping) free(colorMapping);
 590     XPutImage( display, drawable, gc, bmpImage, xSrc, ySrc,
 591                xDest, yDest, width, height );
 592     XDestroyImage( bmpImage );
 593     return lines;
 594 }
 595
 596
 597 /***********************************************************************
 598  *           StretchDIBits16   (GDI.439)
 599  */
 600 INT16 StretchDIBits16( HDC16 hdc, INT16 xDst, INT16 yDst, INT16 widthDst,
 601                        INT16 heightDst, INT16 xSrc, INT16 ySrc, INT16 widthSrc,
 602                        INT16 heightSrc, const VOID *bits,
 603                        const BITMAPINFO *info, UINT16 wUsage, DWORD dwRop )
 604 {
 605     return (INT16)StretchDIBits32( hdc, xDst, yDst, widthDst, heightDst,
 606                                    xSrc, ySrc, widthSrc, heightSrc, bits,
 607                                    info, wUsage, dwRop );
 608 }
 609
 610
 611 /***********************************************************************
 612  *           StretchDIBits32   (GDI32.351)
 613  */
 614 INT32 StretchDIBits32( HDC32 hdc, INT32 xDst, INT32 yDst, INT32 widthDst,
 615                        INT32 heightDst, INT32 xSrc, INT32 ySrc, INT32 widthSrc,
 616                        INT32 heightSrc, const void *bits,
 617                        const BITMAPINFO *info, UINT32 wUsage, DWORD dwRop )
 618 {
 619     HBITMAP32 hBitmap, hOldBitmap;
 620     HDC32 hdcMem;
 621
 622     hBitmap = CreateDIBitmap32( hdc, &info->bmiHeader, CBM_INIT,
 623                                 bits, info, wUsage );
 624     hdcMem = CreateCompatibleDC32( hdc );
 625     hOldBitmap = SelectObject32( hdcMem, hBitmap );
 626     StretchBlt32( hdc, xDst, yDst, widthDst, heightDst,
 627                   hdcMem, xSrc, ySrc, widthSrc, heightSrc, dwRop );
 628     SelectObject32( hdcMem, hOldBitmap );
 629     DeleteDC32( hdcMem );
 630     DeleteObject32( hBitmap );
 631     return heightSrc;
 632 }
 633
 634
 635 /***********************************************************************
 636  *           SetDIBits16    (GDI.440)
 637  */
 638 INT16 SetDIBits16( HDC16 hdc, HBITMAP16 hbitmap, UINT16 startscan,
 639                    UINT16 lines, LPCVOID bits, const BITMAPINFO *info,
 640                    UINT16 coloruse )
 641 {
 642     return SetDIBits32( hdc, hbitmap, startscan, lines, bits, info, coloruse );
 643 }
 644
 645
 646 /***********************************************************************
 647  *           SetDIBits32   (GDI32.312)
 648  */
 649 INT32 SetDIBits32( HDC32 hdc, HBITMAP32 hbitmap, UINT32 startscan,
 650                    UINT32 lines, LPCVOID bits, const BITMAPINFO *info,
 651                    UINT32 coloruse )
 652 {
 653     DC * dc;
 654     BITMAPOBJ * bmp;
 655     DWORD width, height;
 656     WORD bpp;
 657
 658       /* Check parameters */
 659
 660     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 661     if (!dc)
 662     {
 663         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 664         if (!dc) return 0;
 665     }
 666     if (!(bmp = (BITMAPOBJ *)GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
 667         return 0;
 668     if (DIB_GetBitmapInfo( &info->bmiHeader, &width, &height, &bpp ) == -1)
 669         return 0;
 670     if (!lines || (startscan >= (WORD)height)) return 0;
 671     if (startscan + lines > height) lines = height - startscan;
 672
 673     return CallTo32_LargeStack( (int(*)())DIB_SetImageBits, 16,
 674                                 dc, lines, bmp->bitmap.bmBitsPixel,
 675                                 bits, width, bpp, info,
 676                                 coloruse, bmp->pixmap, BITMAP_GC(bmp), 0, 0, 0,
 677                                 height - startscan - lines,
 678                                 bmp->bitmap.bmWidth, lines );
 679 }
 680
 681
 682 /***********************************************************************
 683  *           SetDIBitsToDevice16    (GDI.443)
 684  */
 685 INT16 SetDIBitsToDevice16( HDC16 hdc, INT16 xDest, INT16 yDest, INT16 cx,
 686                            INT16 cy, INT16 xSrc, INT16 ySrc, UINT16 startscan,
 687                            UINT16 lines, LPCVOID bits, const BITMAPINFO *info,
 688                            UINT16 coloruse )
 689 {
 690     return SetDIBitsToDevice32( hdc, xDest, yDest, cx, cy, xSrc, ySrc,
 691                                 startscan, lines, bits, info, coloruse );
 692 }
 693
 694
 695 /***********************************************************************
 696  *           SetDIBitsToDevice32   (GDI32.313)
 697  */
 698 INT32 SetDIBitsToDevice32( HDC32 hdc, INT32 xDest, INT32 yDest, DWORD cx,
 699                            DWORD cy, INT32 xSrc, INT32 ySrc, UINT32 startscan,
 700                            UINT32 lines, LPCVOID bits, const BITMAPINFO *info,
 701                            UINT32 coloruse )
 702 {
 703     DC * dc;
 704     DWORD width, height;
 705     WORD bpp;
 706
 707       /* Check parameters */
 708
 709     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 710     if (!dc)
 711     {
 712         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 713         if (!dc) return 0;
 714     }
 715     if (DIB_GetBitmapInfo( &info->bmiHeader, &width, &height, &bpp ) == -1)
 716         return 0;
 717     if (!lines || (startscan >= height)) return 0;
 718     if (startscan + lines > height) lines = height - startscan;
 719     if (ySrc < startscan) ySrc = startscan;
 720     else if (ySrc >= startscan + lines) return 0;
 721     if (xSrc >= width) return 0;
 722     if (ySrc + cy >= startscan + lines) cy = startscan + lines - ySrc;
 723     if (xSrc + cx >= width) cx = width - xSrc;
 724     if (!cx || !cy) return 0;
 725
 726     DC_SetupGCForText( dc );  /* To have the correct colors */
 727     XSetFunction( display, dc->u.x.gc, DC_XROPfunction[dc->w.ROPmode-1] );
 728     return CallTo32_LargeStack( (int(*)())DIB_SetImageBits, 16,
 729                                 dc, lines, dc->w.bitsPerPixel, bits, width,
 730                                 bpp, info, coloruse,
 731                                 dc->u.x.drawable, dc->u.x.gc,
 732                                 xSrc, ySrc - startscan,
 733                                 dc->w.DCOrgX + XLPTODP( dc, xDest ),
 734                                 dc->w.DCOrgY + YLPTODP( dc, yDest ),
 735                                 cx, cy );
 736 }
 737
 738
 739
 740 /***********************************************************************
 741  *           GetDIBits16    (GDI.441)
 742  */
 743 INT16 GetDIBits16( HDC16 hdc, HBITMAP16 hbitmap, UINT16 startscan,
 744                    UINT16 lines, LPSTR bits, BITMAPINFO * info,
 745                    UINT16 coloruse )
 746 {
 747     return GetDIBits32( hdc, hbitmap, startscan, lines, bits, info, coloruse );
 748 }
 749
 750
 751 /***********************************************************************
 752  *           GetDIBits32    (GDI32.170)
 753  */
 754 INT32 GetDIBits32( HDC32 hdc, HBITMAP32 hbitmap, UINT32 startscan,
 755                    UINT32 lines, LPSTR bits, BITMAPINFO * info,
 756                    UINT32 coloruse )
 757 {
 758     DC * dc;
 759     BITMAPOBJ * bmp;
 760     PALETTEENTRY * palEntry;
 761     PALETTEOBJ * palette;
 762     XImage * bmpImage, * dibImage;
 763     int i, x, y;
 764
 765     if (!lines) return 0;
 766     dc = (DC *) GDI_GetObjPtr( hdc, DC_MAGIC );
 767     if (!dc)
 768     {
 769         dc = (DC *)GDI_GetObjPtr(hdc, METAFILE_DC_MAGIC);
 770         if (!dc) return 0;
 771     }
 772     if (!(bmp = (BITMAPOBJ *)GDI_GetObjPtr( hbitmap, BITMAP_MAGIC )))
 773         return 0;
 774     if (!(palette = (PALETTEOBJ*)GDI_GetObjPtr( dc->w.hPalette, PALETTE_MAGIC )))
 775         return 0;
 776
 777       /* Transfer color info */
 778
 779     palEntry = palette->logpalette.palPalEntry;
 780     for (i = 0; i < info->bmiHeader.biClrUsed; i++, palEntry++)
 781     {
 782         if (coloruse == DIB_RGB_COLORS)
 783         {
 784             info->bmiColors[i].rgbRed      = palEntry->peRed;
 785             info->bmiColors[i].rgbGreen    = palEntry->peGreen;
 786             info->bmiColors[i].rgbBlue     = palEntry->peBlue;
 787             info->bmiColors[i].rgbReserved = 0;
 788         }
 789         else ((WORD *)info->bmiColors)[i] = (WORD)i;
 790     }
 791
 792     if (bits)
 793     {
 794         BYTE*   bbits = bits;
 795         int     pad, yend, xend = bmp->bitmap.bmWidth;
 796
 797         dprintf_bitmap(stddeb, "GetDIBits: %u scanlines of (%i,%i) -> (%i,%i) starting from %u\n",
 798                             lines, bmp->bitmap.bmWidth, bmp->bitmap.bmHeight,
 799                             (int)info->bmiHeader.biWidth, (int)info->bmiHeader.biHeight, startscan );
 800
 801         /* adjust number of scanlines to copy */
 802
 803         if( lines > info->bmiHeader.biHeight ) lines = info->bmiHeader.biHeight;
 804         yend = startscan + lines;
 805         if( startscan >= bmp->bitmap.bmHeight )
 806             return FALSE;
 807         if( yend > bmp->bitmap.bmHeight ) yend = bmp->bitmap.bmHeight;
 808
 809         /* adjust scanline width */
 810
 811         pad = info->bmiHeader.biWidth - bmp->bitmap.bmWidth;
 812         if( pad < 0 )
 813         {
 814             /* bitmap is wider than DIB, copy only a part */
 815
 816             pad = 0; xend = info->bmiHeader.biWidth;
 817         }
 818
 819         bmpImage = (XImage *)CallTo32_LargeStack( (int (*)())XGetImage, 8,
 820                                display, bmp->pixmap, 0, 0, bmp->bitmap.bmWidth,
 821                                bmp->bitmap.bmHeight, AllPlanes, ZPixmap );
 822
 823         switch( info->bmiHeader.biBitCount )
 824         {
 825            case 8:
 826
 827                 pad += (4 - (info->bmiHeader.biWidth & 3)) & 3;
 828                 for( y = yend - 1; (int)y >= (int)startscan; y-- )
 829                 {
 830                    for( x = 0; x < xend; x++ )
 831                         *bbits++ = XGetPixel( bmpImage, x, y );
 832                    bbits += pad;
 833                 }
 834                 break;
 835
 836 /* add more bpp-specific shortcuts here */
 837
 838            default:
 839
 840                 dibImage = XCreateImage(display, DefaultVisualOfScreen( screen ),
 841                            info->bmiHeader.biBitCount, ZPixmap, 0, bits,
 842                            info->bmiHeader.biWidth, info->bmiHeader.biHeight,
 843                            32, DIB_GetImageWidthBytes( info->bmiHeader.biWidth,
 844                                                 info->bmiHeader.biBitCount ) );
 845                 if( dibImage )
 846                 {
 847                     extern void _XInitImageFuncPtrs( XImage* );
 848
 849                     dibImage->byte_order = MSBFirst;
 850                     dibImage->bitmap_bit_order = MSBFirst;
 851                     dibImage->bitmap_unit = 16;
 852                     _XInitImageFuncPtrs( dibImage );
 853
 854                     for (y = yend - 1; (int)y >= (int)startscan; y--)
 855                         for (x = 0; x < xend; x++)
 856                             XPutPixel( dibImage, x, yend - y + 1,
 857                                        XGetPixel( bmpImage, x, y ));
 858                     dibImage->data = NULL;
 859                     XDestroyImage( dibImage );
 860                 }
 861         }
 862
 863         XDestroyImage( bmpImage );
 864
 865         info->bmiHeader.biCompression = 0;
 866     }
 867     else if( info->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) )
 868     {
 869         /* fill in struct members */
 870
 871         info->bmiHeader.biWidth = bmp->bitmap.bmWidth;
 872         info->bmiHeader.biHeight = bmp->bitmap.bmHeight;
 873         info->bmiHeader.biPlanes = 1;
 874         info->bmiHeader.biBitCount = bmp->bitmap.bmBitsPixel;
 875         info->bmiHeader.biSizeImage = bmp->bitmap.bmHeight *
 876                              DIB_GetImageWidthBytes( bmp->bitmap.bmWidth,
 877                                                      bmp->bitmap.bmBitsPixel );
 878         info->bmiHeader.biCompression = 0;
 879     }
 880
 881     return lines;
 882 }
 883
 884
 885 /***********************************************************************
 886  *           CreateDIBitmap16    (GDI.442)
 887  */
 888 HBITMAP16 CreateDIBitmap16( HDC16 hdc, const BITMAPINFOHEADER * header,
 889                             DWORD init, LPCVOID bits, const BITMAPINFO * data,
 890                             UINT16 coloruse )
 891 {
 892     return CreateDIBitmap32( hdc, header, init, bits, data, coloruse );
 893 }
 894
 895
 896 /***********************************************************************
 897  *           CreateDIBitmap32    (GDI32.37)
 898  */
 899 HBITMAP32 CreateDIBitmap32( HDC32 hdc, const BITMAPINFOHEADER *header,
 900                             DWORD init, LPCVOID bits, const BITMAPINFO *data,
 901                             UINT32 coloruse )
 902 {
 903     HBITMAP32 handle;
 904     BOOL32 fColor;
 905     DWORD width, height;
 906     WORD bpp;
 907
 908     if (DIB_GetBitmapInfo( header, &width, &height, &bpp ) == -1) return 0;
 909
 910     /* Check if we should create a monochrome or color bitmap. */
 911     /* We create a monochrome bitmap only if it has exactly 2  */
 912     /* colors, which are either black or white, nothing else.  */
 913     /* In all other cases, we create a color bitmap.           */
 914
 915     if (bpp != 1) fColor = TRUE;
 916     else if ((coloruse != DIB_RGB_COLORS) ||
 917              (init != CBM_INIT) || !data) fColor = FALSE;
 918     else
 919     {
 920         if (data->bmiHeader.biSize == sizeof(BITMAPINFOHEADER))
 921         {
 922             RGBQUAD *rgb = data->bmiColors;
 923             DWORD col = RGB( rgb->rgbRed, rgb->rgbGreen, rgb->rgbBlue );
 924             if ((col == RGB(0,0,0)) || (col == RGB(0xff,0xff,0xff)))
 925             {
 926                 rgb++;
 927                 col = RGB( rgb->rgbRed, rgb->rgbGreen, rgb->rgbBlue );
 928                 fColor = ((col != RGB(0,0,0)) && (col != RGB(0xff,0xff,0xff)));
 929             }
 930             else fColor = TRUE;
 931         }
 932         else if (data->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
 933         {
 934             RGBTRIPLE *rgb = ((BITMAPCOREINFO *)data)->bmciColors;
 935             DWORD col = RGB( rgb->rgbtRed, rgb->rgbtGreen, rgb->rgbtBlue );
 936             if ((col == RGB(0,0,0)) || (col == RGB(0xff,0xff,0xff)))
 937             {
 938                 rgb++;
 939                 col = RGB( rgb->rgbtRed, rgb->rgbtGreen, rgb->rgbtBlue );
 940                 fColor = ((col != RGB(0,0,0)) && (col != RGB(0xff,0xff,0xff)));
 941             }
 942             else fColor = TRUE;
 943         }
 944         else
 945         {
 946             fprintf( stderr, "CreateDIBitmap: wrong size (%ld) for data\n",
 947                      data->bmiHeader.biSize );
 948             return 0;
 949         }
 950     }
 951
 952     /* Now create the bitmap */
 953
 954     handle = fColor ? CreateCompatibleBitmap32( hdc, width, height ) :
 955                       CreateBitmap32( width, height, 1, 1, NULL );
 956     if (!handle) return 0;
 957
 958     if (init == CBM_INIT)
 959         SetDIBits32( hdc, handle, 0, height, bits, data, coloruse );
 960     return handle;
 961 }