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

   1 /*
   2  * GDI device-independent bitmaps
   3  *
   4  * Copyright 1993,1994  Alexandre Julliard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 /*
  22   Important information:
  23
  24   * Current Windows versions support two different DIB structures:
  25
  26     - BITMAPCOREINFO / BITMAPCOREHEADER (legacy structures; used in OS/2)
  27     - BITMAPINFO / BITMAPINFOHEADER
  28
  29     Most Windows API functions taking a BITMAPINFO* / BITMAPINFOHEADER* also
  30     accept the old "core" structures, and so must WINE.
  31     You can distinguish them by looking at the first member (bcSize/biSize),
  32     or use the internal function DIB_GetBitmapInfo.
  33
  34
  35   * The palettes are stored in different formats:
  36
  37     - BITMAPCOREINFO: Array of RGBTRIPLE
  38     - BITMAPINFO:     Array of RGBQUAD
  39
  40
  41   * There are even more DIB headers, but they all extend BITMAPINFOHEADER:
  42
  43     - BITMAPV4HEADER: Introduced in Windows 95 / NT 4.0
  44     - BITMAPV5HEADER: Introduced in Windows 98 / 2000
  45
  46     If biCompression is BI_BITFIELDS, the color masks are at the same position
  47     in all the headers (they start at bmiColors of BITMAPINFOHEADER), because
  48     the new headers have structure members for the masks.
  49
  50
  51   * You should never access the color table using the bmiColors member,
  52     because the passed structure may have one of the extended headers
  53     mentioned above. Use this to calculate the location:
  54
  55     BITMAPINFO* info;
  56     void* colorPtr = (LPBYTE) info + (WORD) info->bmiHeader.biSize;
  57
  58
  59   * More information:
  60     Search for "Bitmap Structures" in MSDN
  61 */
  62
  63 #include <stdarg.h>
  64 #include <stdlib.h>
  65 #include <string.h>
  66
  67 #include "windef.h"
  68 #include "winbase.h"
  69 #include "gdi_private.h"
  70 #include "wine/debug.h"
  71
  72 WINE_DEFAULT_DEBUG_CHANNEL(bitmap);
  73
  74
  75 /*
  76   Some of the following helper functions are duplicated in
  77   dlls/x11drv/dib.c
  78 */
  79
  80 /***********************************************************************
  81  *           DIB_GetDIBWidthBytes
  82  *
  83  * Return the width of a DIB bitmap in bytes. DIB bitmap data is 32-bit aligned.
  84  */
  85 int DIB_GetDIBWidthBytes( int width, int depth )
  86 {
  87     int words;
  88
  89     switch(depth)
  90     {
  91         case 1:  words = (width + 31) / 32; break;
  92         case 4:  words = (width + 7) / 8; break;
  93         case 8:  words = (width + 3) / 4; break;
  94         case 15:
  95         case 16: words = (width + 1) / 2; break;
  96         case 24: words = (width * 3 + 3)/4; break;
  97
  98         default:
  99             WARN("(%d): Unsupported depth\n", depth );
 100         /* fall through */
 101         case 32:
 102                 words = width;
 103     }
 104     return 4 * words;
 105 }
 106
 107 /***********************************************************************
 108  *           DIB_GetDIBImageBytes
 109  *
 110  * Return the number of bytes used to hold the image in a DIB bitmap.
 111  */
 112 int DIB_GetDIBImageBytes( int width, int height, int depth )
 113 {
 114     return DIB_GetDIBWidthBytes( width, depth ) * abs( height );
 115 }
 116
 117
 118 /***********************************************************************
 119  *           bitmap_info_size
 120  *
 121  * Return the size of the bitmap info structure including color table.
 122  */
 123 int bitmap_info_size( const BITMAPINFO * info, WORD coloruse )
 124 {
 125     unsigned int colors, size, masks = 0;
 126
 127     if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
 128     {
 129         const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)info;
 130         colors = (core->bcBitCount <= 8) ? 1 << core->bcBitCount : 0;
 131         return sizeof(BITMAPCOREHEADER) + colors *
 132              ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
 133     }
 134     else  /* assume BITMAPINFOHEADER */
 135     {
 136         colors = info->bmiHeader.biClrUsed;
 137         if (colors > 256) colors = 256;
 138         if (!colors && (info->bmiHeader.biBitCount <= 8))
 139             colors = 1 << info->bmiHeader.biBitCount;
 140         if (info->bmiHeader.biCompression == BI_BITFIELDS) masks = 3;
 141         size = max( info->bmiHeader.biSize, sizeof(BITMAPINFOHEADER) + masks * sizeof(DWORD) );
 142         return size + colors * ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
 143     }
 144 }
 145
 146
 147 /***********************************************************************
 148  *           DIB_GetBitmapInfo
 149  *
 150  * Get the info from a bitmap header.
 151  * Return 0 for COREHEADER, 1 for INFOHEADER, -1 for error.
 152  */
 153 int DIB_GetBitmapInfo( const BITMAPINFOHEADER *header, LONG *width,
 154                        LONG *height, WORD *planes, WORD *bpp, DWORD *compr, DWORD *size )
 155 {
 156     if (header->biSize == sizeof(BITMAPCOREHEADER))
 157     {
 158         const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)header;
 159         *width  = core->bcWidth;
 160         *height = core->bcHeight;
 161         *planes = core->bcPlanes;
 162         *bpp    = core->bcBitCount;
 163         *compr  = 0;
 164         *size   = 0;
 165         return 0;
 166     }
 167     if (header->biSize >= sizeof(BITMAPINFOHEADER)) /* assume BITMAPINFOHEADER */
 168     {
 169         *width  = header->biWidth;
 170         *height = header->biHeight;
 171         *planes = header->biPlanes;
 172         *bpp    = header->biBitCount;
 173         *compr  = header->biCompression;
 174         *size   = header->biSizeImage;
 175         return 1;
 176     }
 177     ERR("(%d): unknown/wrong size for header\n", header->biSize );
 178     return -1;
 179 }
 180
 181 /* nulldrv fallback implementation using SetDIBits/StretchBlt */
 182 INT CDECL nulldrv_StretchDIBits( PHYSDEV dev, INT xDst, INT yDst, INT widthDst, INT heightDst,
 183                                  INT xSrc, INT ySrc, INT widthSrc, INT heightSrc, const void *bits,
 184                                  const BITMAPINFO *info, UINT coloruse, DWORD rop )
 185 {
 186     DC *dc = get_nulldrv_dc( dev );
 187     INT ret;
 188     LONG width, height;
 189     WORD planes, bpp;
 190     DWORD compr, size;
 191     HBITMAP hBitmap;
 192     HDC hdcMem;
 193
 194     /* make sure we have a real implementation for StretchBlt and SetDIBits */
 195     if (GET_DC_PHYSDEV( dc, pStretchBlt ) == dev || GET_DC_PHYSDEV( dc, pSetDIBits ) == dev)
 196         return 0;
 197
 198     if (DIB_GetBitmapInfo( &info->bmiHeader, &width, &height, &planes, &bpp, &compr, &size ) == -1)
 199         return 0;
 200
 201     if (width < 0) return 0;
 202
 203     if (xSrc == 0 && ySrc == 0 && widthDst == widthSrc && heightDst == heightSrc &&
 204         info->bmiHeader.biCompression == BI_RGB)
 205     {
 206         /* Windows appears to have a fast case optimization
 207          * that uses the wrong origin for top-down DIBs */
 208         if (height < 0 && heightSrc < abs(height)) ySrc = abs(height) - heightSrc;
 209
 210         if (xDst == 0 && yDst == 0 && info->bmiHeader.biCompression == BI_RGB && rop == SRCCOPY)
 211         {
 212             BITMAP bm;
 213             hBitmap = GetCurrentObject( dev->hdc, OBJ_BITMAP );
 214             if (GetObjectW( hBitmap, sizeof(bm), &bm ) &&
 215                 bm.bmWidth == widthSrc && bm.bmHeight == heightSrc &&
 216                 bm.bmBitsPixel == bpp && bm.bmPlanes == planes)
 217             {
 218                 /* fast path */
 219                 return SetDIBits( dev->hdc, hBitmap, 0, height, bits, info, coloruse );
 220             }
 221         }
 222     }
 223
 224     hdcMem = CreateCompatibleDC( dev->hdc );
 225     hBitmap = CreateCompatibleBitmap( dev->hdc, width, height );
 226     SelectObject( hdcMem, hBitmap );
 227     if (coloruse == DIB_PAL_COLORS)
 228         SelectPalette( hdcMem, GetCurrentObject( dev->hdc, OBJ_PAL ), FALSE );
 229
 230     if (info->bmiHeader.biCompression == BI_RLE4 || info->bmiHeader.biCompression == BI_RLE8)
 231     {
 232         /* when RLE compression is used, there may be some gaps (ie the DIB doesn't
 233          * contain all the rectangle described in bmiHeader, but only part of it.
 234          * This mean that those undescribed pixels must be left untouched.
 235          * So, we first copy on a memory bitmap the current content of the
 236          * destination rectangle, blit the DIB bits on top of it - hence leaving
 237          * the gaps untouched -, and blitting the rectangle back.
 238          * This insure that gaps are untouched on the destination rectangle
 239          */
 240         StretchBlt( hdcMem, xSrc, abs(height) - heightSrc - ySrc, widthSrc, heightSrc,
 241                     dev->hdc, xDst, yDst, widthDst, heightDst, rop );
 242     }
 243     ret = SetDIBits( hdcMem, hBitmap, 0, height, bits, info, coloruse );
 244     if (ret) StretchBlt( dev->hdc, xDst, yDst, widthDst, heightDst,
 245                          hdcMem, xSrc, abs(height) - heightSrc - ySrc, widthSrc, heightSrc, rop );
 246     DeleteDC( hdcMem );
 247     DeleteObject( hBitmap );
 248     return ret;
 249 }
 250
 251 /***********************************************************************
 252  *           StretchDIBits   (GDI32.@)
 253  */
 254 INT WINAPI StretchDIBits(HDC hdc, INT xDst, INT yDst, INT widthDst, INT heightDst,
 255                          INT xSrc, INT ySrc, INT widthSrc, INT heightSrc, const void *bits,
 256                          const BITMAPINFO *info, UINT coloruse, DWORD rop )
 257 {
 258     DC *dc;
 259     INT ret = 0;
 260
 261     if (!bits || !info) return 0;
 262
 263     if ((dc = get_dc_ptr( hdc )))
 264     {
 265         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pStretchDIBits );
 266         update_dc( dc );
 267         ret = physdev->funcs->pStretchDIBits( physdev, xDst, yDst, widthDst, heightDst,
 268                                               xSrc, ySrc, widthSrc, heightSrc, bits, info, coloruse, rop );
 269         release_dc_ptr( dc );
 270     }
 271     return ret;
 272 }
 273
 274
 275 /******************************************************************************
 276  * SetDIBits [GDI32.@]
 277  *
 278  * Sets pixels in a bitmap using colors from DIB.
 279  *
 280  * PARAMS
 281  *    hdc       [I] Handle to device context
 282  *    hbitmap   [I] Handle to bitmap
 283  *    startscan [I] Starting scan line
 284  *    lines     [I] Number of scan lines
 285  *    bits      [I] Array of bitmap bits
 286  *    info      [I] Address of structure with data
 287  *    coloruse  [I] Type of color indexes to use
 288  *
 289  * RETURNS
 290  *    Success: Number of scan lines copied
 291  *    Failure: 0
 292  */
 293 INT WINAPI SetDIBits( HDC hdc, HBITMAP hbitmap, UINT startscan,
 294                       UINT lines, LPCVOID bits, const BITMAPINFO *info,
 295                       UINT coloruse )
 296 {
 297     DC *dc = get_dc_ptr( hdc );
 298     BOOL delete_hdc = FALSE;
 299     PHYSDEV physdev;
 300     BITMAPOBJ *bitmap;
 301     INT result = 0;
 302
 303     if (coloruse == DIB_RGB_COLORS && !dc)
 304     {
 305         hdc = CreateCompatibleDC(0);
 306         dc = get_dc_ptr( hdc );
 307         delete_hdc = TRUE;
 308     }
 309
 310     if (!dc) return 0;
 311
 312     update_dc( dc );
 313
 314     if (!(bitmap = GDI_GetObjPtr( hbitmap, OBJ_BITMAP )))
 315     {
 316         release_dc_ptr( dc );
 317         if (delete_hdc) DeleteDC(hdc);
 318         return 0;
 319     }
 320
 321     physdev = GET_DC_PHYSDEV( dc, pSetDIBits );
 322     if (BITMAP_SetOwnerDC( hbitmap, physdev ))
 323         result = physdev->funcs->pSetDIBits( physdev, hbitmap, startscan, lines, bits, info, coloruse );
 324
 325     GDI_ReleaseObj( hbitmap );
 326     release_dc_ptr( dc );
 327     if (delete_hdc) DeleteDC(hdc);
 328     return result;
 329 }
 330
 331
 332 /***********************************************************************
 333  *           SetDIBitsToDevice   (GDI32.@)
 334  */
 335 INT WINAPI SetDIBitsToDevice(HDC hdc, INT xDest, INT yDest, DWORD cx,
 336                            DWORD cy, INT xSrc, INT ySrc, UINT startscan,
 337                            UINT lines, LPCVOID bits, const BITMAPINFO *info,
 338                            UINT coloruse )
 339 {
 340     INT ret = 0;
 341     DC *dc;
 342
 343     if (!bits) return 0;
 344
 345     if ((dc = get_dc_ptr( hdc )))
 346     {
 347         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDIBitsToDevice );
 348         update_dc( dc );
 349         ret = physdev->funcs->pSetDIBitsToDevice( physdev, xDest, yDest, cx, cy, xSrc,
 350                                                   ySrc, startscan, lines, bits, info, coloruse );
 351         release_dc_ptr( dc );
 352     }
 353     return ret;
 354 }
 355
 356 /***********************************************************************
 357  *           SetDIBColorTable    (GDI32.@)
 358  */
 359 UINT WINAPI SetDIBColorTable( HDC hdc, UINT startpos, UINT entries, CONST RGBQUAD *colors )
 360 {
 361     DC * dc;
 362     UINT result = 0;
 363     BITMAPOBJ * bitmap;
 364
 365     if (!(dc = get_dc_ptr( hdc ))) return 0;
 366
 367     if ((bitmap = GDI_GetObjPtr( dc->hBitmap, OBJ_BITMAP )))
 368     {
 369         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pSetDIBColorTable );
 370
 371         /* Check if currently selected bitmap is a DIB */
 372         if (bitmap->color_table)
 373         {
 374             if (startpos < bitmap->nb_colors)
 375             {
 376                 if (startpos + entries > bitmap->nb_colors) entries = bitmap->nb_colors - startpos;
 377                 memcpy(bitmap->color_table + startpos, colors, entries * sizeof(RGBQUAD));
 378                 result = entries;
 379             }
 380         }
 381         GDI_ReleaseObj( dc->hBitmap );
 382         physdev->funcs->pSetDIBColorTable( physdev, startpos, entries, colors );
 383     }
 384     release_dc_ptr( dc );
 385     return result;
 386 }
 387
 388
 389 /***********************************************************************
 390  *           GetDIBColorTable    (GDI32.@)
 391  */
 392 UINT WINAPI GetDIBColorTable( HDC hdc, UINT startpos, UINT entries, RGBQUAD *colors )
 393 {
 394     DC * dc;
 395     BITMAPOBJ *bitmap;
 396     UINT result = 0;
 397
 398     if (!(dc = get_dc_ptr( hdc ))) return 0;
 399
 400     if ((bitmap = GDI_GetObjPtr( dc->hBitmap, OBJ_BITMAP )))
 401     {
 402         /* Check if currently selected bitmap is a DIB */
 403         if (bitmap->color_table)
 404         {
 405             if (startpos < bitmap->nb_colors)
 406             {
 407                 if (startpos + entries > bitmap->nb_colors) entries = bitmap->nb_colors - startpos;
 408                 memcpy(colors, bitmap->color_table + startpos, entries * sizeof(RGBQUAD));
 409                 result = entries;
 410             }
 411         }
 412         GDI_ReleaseObj( dc->hBitmap );
 413     }
 414     release_dc_ptr( dc );
 415     return result;
 416 }
 417
 418 /* FIXME the following two structs should be combined with __sysPalTemplate in
 419    objects/color.c - this should happen after de-X11-ing both of these
 420    files.
 421    NB. RGBQUAD and PALETTEENTRY have different orderings of red, green
 422    and blue - sigh */
 423
 424 static const RGBQUAD EGAColorsQuads[16] = {
 425 /* rgbBlue, rgbGreen, rgbRed, rgbReserved */
 426     { 0x00, 0x00, 0x00, 0x00 },
 427     { 0x00, 0x00, 0x80, 0x00 },
 428     { 0x00, 0x80, 0x00, 0x00 },
 429     { 0x00, 0x80, 0x80, 0x00 },
 430     { 0x80, 0x00, 0x00, 0x00 },
 431     { 0x80, 0x00, 0x80, 0x00 },
 432     { 0x80, 0x80, 0x00, 0x00 },
 433     { 0x80, 0x80, 0x80, 0x00 },
 434     { 0xc0, 0xc0, 0xc0, 0x00 },
 435     { 0x00, 0x00, 0xff, 0x00 },
 436     { 0x00, 0xff, 0x00, 0x00 },
 437     { 0x00, 0xff, 0xff, 0x00 },
 438     { 0xff, 0x00, 0x00, 0x00 },
 439     { 0xff, 0x00, 0xff, 0x00 },
 440     { 0xff, 0xff, 0x00, 0x00 },
 441     { 0xff, 0xff, 0xff, 0x00 }
 442 };
 443
 444 static const RGBQUAD DefLogPaletteQuads[20] = { /* Copy of Default Logical Palette */
 445 /* rgbBlue, rgbGreen, rgbRed, rgbReserved */
 446     { 0x00, 0x00, 0x00, 0x00 },
 447     { 0x00, 0x00, 0x80, 0x00 },
 448     { 0x00, 0x80, 0x00, 0x00 },
 449     { 0x00, 0x80, 0x80, 0x00 },
 450     { 0x80, 0x00, 0x00, 0x00 },
 451     { 0x80, 0x00, 0x80, 0x00 },
 452     { 0x80, 0x80, 0x00, 0x00 },
 453     { 0xc0, 0xc0, 0xc0, 0x00 },
 454     { 0xc0, 0xdc, 0xc0, 0x00 },
 455     { 0xf0, 0xca, 0xa6, 0x00 },
 456     { 0xf0, 0xfb, 0xff, 0x00 },
 457     { 0xa4, 0xa0, 0xa0, 0x00 },
 458     { 0x80, 0x80, 0x80, 0x00 },
 459     { 0x00, 0x00, 0xff, 0x00 },
 460     { 0x00, 0xff, 0x00, 0x00 },
 461     { 0x00, 0xff, 0xff, 0x00 },
 462     { 0xff, 0x00, 0x00, 0x00 },
 463     { 0xff, 0x00, 0xff, 0x00 },
 464     { 0xff, 0xff, 0x00, 0x00 },
 465     { 0xff, 0xff, 0xff, 0x00 }
 466 };
 467
 468 /******************************************************************************
 469  * GetDIBits [GDI32.@]
 470  *
 471  * Retrieves bits of bitmap and copies to buffer.
 472  *
 473  * RETURNS
 474  *    Success: Number of scan lines copied from bitmap
 475  *    Failure: 0
 476  */
 477 INT WINAPI GetDIBits(
 478     HDC hdc,         /* [in]  Handle to device context */
 479     HBITMAP hbitmap, /* [in]  Handle to bitmap */
 480     UINT startscan,  /* [in]  First scan line to set in dest bitmap */
 481     UINT lines,      /* [in]  Number of scan lines to copy */
 482     LPVOID bits,       /* [out] Address of array for bitmap bits */
 483     BITMAPINFO * info, /* [out] Address of structure with bitmap data */
 484     UINT coloruse)   /* [in]  RGB or palette index */
 485 {
 486     DC * dc;
 487     BITMAPOBJ * bmp;
 488     int i;
 489     int bitmap_type;
 490     BOOL core_header;
 491     LONG width;
 492     LONG height;
 493     WORD planes, bpp;
 494     DWORD compr, size;
 495     void* colorPtr;
 496     RGBQUAD quad_buf[256];
 497     RGBQUAD* rgbQuads = quad_buf;
 498
 499     if (!info) return 0;
 500
 501     bitmap_type = DIB_GetBitmapInfo( &info->bmiHeader, &width, &height, &planes, &bpp, &compr, &size);
 502     if (bitmap_type == -1)
 503     {
 504         ERR("Invalid bitmap format\n");
 505         return 0;
 506     }
 507     core_header = (bitmap_type == 0);
 508     if (!(dc = get_dc_ptr( hdc )))
 509     {
 510         SetLastError( ERROR_INVALID_PARAMETER );
 511         return 0;
 512     }
 513     update_dc( dc );
 514     if (!(bmp = GDI_GetObjPtr( hbitmap, OBJ_BITMAP )))
 515     {
 516         release_dc_ptr( dc );
 517         return 0;
 518     }
 519
 520     colorPtr = (LPBYTE) info + (WORD) info->bmiHeader.biSize;
 521     if(!core_header) rgbQuads = colorPtr;
 522
 523     /* Transfer color info */
 524
 525     switch (bpp)
 526     {
 527     case 0:  /* query bitmap info only */
 528         if (core_header)
 529         {
 530             BITMAPCOREHEADER* coreheader = (BITMAPCOREHEADER*) info;
 531             coreheader->bcWidth = bmp->bitmap.bmWidth;
 532             coreheader->bcHeight = bmp->bitmap.bmHeight;
 533             coreheader->bcPlanes = 1;
 534             coreheader->bcBitCount = bmp->bitmap.bmBitsPixel;
 535         }
 536         else
 537         {
 538             info->bmiHeader.biWidth = bmp->bitmap.bmWidth;
 539             info->bmiHeader.biHeight = bmp->bitmap.bmHeight;
 540             info->bmiHeader.biPlanes = 1;
 541             info->bmiHeader.biSizeImage =
 542                 DIB_GetDIBImageBytes( bmp->bitmap.bmWidth,
 543                                       bmp->bitmap.bmHeight,
 544                                       bmp->bitmap.bmBitsPixel );
 545             if (bmp->dib)
 546             {
 547                 info->bmiHeader.biBitCount = bmp->dib->dsBm.bmBitsPixel;
 548                 switch (bmp->dib->dsBm.bmBitsPixel)
 549                 {
 550                 case 16:
 551                 case 32:
 552                     info->bmiHeader.biCompression = BI_BITFIELDS;
 553                     break;
 554                 default:
 555                     info->bmiHeader.biCompression = BI_RGB;
 556                     break;
 557                 }
 558             }
 559             else
 560             {
 561                 info->bmiHeader.biCompression = (bmp->bitmap.bmBitsPixel > 8) ? BI_BITFIELDS : BI_RGB;
 562                 info->bmiHeader.biBitCount = bmp->bitmap.bmBitsPixel;
 563             }
 564             info->bmiHeader.biXPelsPerMeter = 0;
 565             info->bmiHeader.biYPelsPerMeter = 0;
 566             info->bmiHeader.biClrUsed = 0;
 567             info->bmiHeader.biClrImportant = 0;
 568
 569             /* Windows 2000 doesn't touch the additional struct members if
 570                it's a BITMAPV4HEADER or a BITMAPV5HEADER */
 571         }
 572         lines = abs(bmp->bitmap.bmHeight);
 573         goto done;
 574
 575     case 1:
 576     case 4:
 577     case 8:
 578     {
 579         unsigned int colors = 1 << bpp;
 580
 581         if (!core_header) info->bmiHeader.biClrUsed = 0;
 582
 583         if (coloruse == DIB_PAL_COLORS)
 584         {
 585             WORD *index = colorPtr;
 586             for (i = 0; i < colors; i++, index++)
 587                 *index = i;
 588
 589             break;
 590         }
 591
 592         /* If the bitmap object already has a dib section at the
 593            same color depth then get the color map from it */
 594
 595         if (bmp->dib && bmp->dib->dsBm.bmBitsPixel == bpp)
 596         {
 597             colors = min( colors, bmp->nb_colors );
 598
 599             if (!core_header && colors != 1 << bpp) info->bmiHeader.biClrUsed = colors;
 600
 601             memcpy(rgbQuads, bmp->color_table, colors * sizeof(RGBQUAD));
 602         }
 603
 604         /* For color DDBs in native depth (mono DDBs always have a black/white palette):
 605            Generate the color map from the selected palette */
 606
 607         else if (bpp > 1 && bpp == bmp->bitmap.bmBitsPixel)
 608         {
 609             PALETTEENTRY palEntry[256];
 610
 611             memset( palEntry, 0, sizeof(palEntry) );
 612             if (!GetPaletteEntries( dc->hPalette, 0, colors, palEntry ))
 613             {
 614                 release_dc_ptr( dc );
 615                 GDI_ReleaseObj( hbitmap );
 616                 return 0;
 617             }
 618             for (i = 0; i < colors; i++)
 619             {
 620                 rgbQuads[i].rgbRed      = palEntry[i].peRed;
 621                 rgbQuads[i].rgbGreen    = palEntry[i].peGreen;
 622                 rgbQuads[i].rgbBlue     = palEntry[i].peBlue;
 623                 rgbQuads[i].rgbReserved = 0;
 624             }
 625         }
 626         else
 627         {
 628             switch (bpp)
 629             {
 630             case 1:
 631                 rgbQuads[0].rgbRed = rgbQuads[0].rgbGreen = rgbQuads[0].rgbBlue = 0;
 632                 rgbQuads[0].rgbReserved = 0;
 633                 rgbQuads[1].rgbRed = rgbQuads[1].rgbGreen = rgbQuads[1].rgbBlue = 0xff;
 634                 rgbQuads[1].rgbReserved = 0;
 635                 break;
 636
 637             case 4:
 638                 memcpy(rgbQuads, EGAColorsQuads, sizeof(EGAColorsQuads));
 639                 break;
 640
 641             case 8:
 642                 memcpy(rgbQuads, DefLogPaletteQuads, 10 * sizeof(RGBQUAD));
 643                 memcpy(rgbQuads + 246, DefLogPaletteQuads + 10, 10 * sizeof(RGBQUAD));
 644                 for (i = 10; i < 246; i++)
 645                 {
 646                     rgbQuads[i].rgbRed      = (i & 0x07) << 5;
 647                     rgbQuads[i].rgbGreen    = (i & 0x38) << 2;
 648                     rgbQuads[i].rgbBlue     =  i & 0xc0;
 649                     rgbQuads[i].rgbReserved = 0;
 650                 }
 651             }
 652         }
 653
 654         if(core_header)
 655         {
 656             RGBTRIPLE *triple = (RGBTRIPLE *)colorPtr;
 657             for (i = 0; i < colors; i++)
 658             {
 659                 triple[i].rgbtRed   = rgbQuads[i].rgbRed;
 660                 triple[i].rgbtGreen = rgbQuads[i].rgbGreen;
 661                 triple[i].rgbtBlue  = rgbQuads[i].rgbBlue;
 662             }
 663         }
 664
 665         break;
 666     }
 667
 668     case 15:
 669         if (info->bmiHeader.biCompression == BI_BITFIELDS)
 670         {
 671             ((PDWORD)info->bmiColors)[0] = 0x7c00;
 672             ((PDWORD)info->bmiColors)[1] = 0x03e0;
 673             ((PDWORD)info->bmiColors)[2] = 0x001f;
 674         }
 675         break;
 676
 677     case 16:
 678         if (info->bmiHeader.biCompression == BI_BITFIELDS)
 679         {
 680             if (bmp->dib)
 681             {
 682                 if (bmp->dib->dsBmih.biCompression == BI_BITFIELDS)
 683                     memcpy( info->bmiColors, bmp->dib->dsBitfields, 3 * sizeof(DWORD) );
 684                 else
 685                 {
 686                     ((PDWORD)info->bmiColors)[0] = 0x7c00;
 687                     ((PDWORD)info->bmiColors)[1] = 0x03e0;
 688                     ((PDWORD)info->bmiColors)[2] = 0x001f;
 689                 }
 690             }
 691             else
 692             {
 693                 ((PDWORD)info->bmiColors)[0] = 0xf800;
 694                 ((PDWORD)info->bmiColors)[1] = 0x07e0;
 695                 ((PDWORD)info->bmiColors)[2] = 0x001f;
 696             }
 697         }
 698         break;
 699
 700     case 24:
 701     case 32:
 702         if (info->bmiHeader.biCompression == BI_BITFIELDS)
 703         {
 704             if (bmp->dib && bmp->dib->dsBmih.biCompression == BI_BITFIELDS)
 705                 memcpy( info->bmiColors, bmp->dib->dsBitfields, 3 * sizeof(DWORD) );
 706             else
 707             {
 708                 ((PDWORD)info->bmiColors)[0] = 0xff0000;
 709                 ((PDWORD)info->bmiColors)[1] = 0x00ff00;
 710                 ((PDWORD)info->bmiColors)[2] = 0x0000ff;
 711             }
 712         }
 713         break;
 714     }
 715
 716     if (bits && lines)
 717     {
 718         /* If the bitmap object already have a dib section that contains image data, get the bits from it */
 719         if(bmp->dib && bmp->dib->dsBm.bmBitsPixel >= 15 && bpp >= 15)
 720         {
 721             /*FIXME: Only RGB dibs supported for now */
 722             unsigned int srcwidth = bmp->dib->dsBm.bmWidth;
 723             int srcwidthb = bmp->dib->dsBm.bmWidthBytes;
 724             unsigned int dstwidth = width;
 725             int dstwidthb = DIB_GetDIBWidthBytes( width, bpp );
 726             LPBYTE dbits = bits, sbits = (LPBYTE) bmp->dib->dsBm.bmBits + (startscan * srcwidthb);
 727             unsigned int x, y, width, widthb;
 728
 729             /*
 730              * If copying from a top-down source bitmap, move the source
 731              * pointer to the end of the source bitmap and negate the width
 732              * so that we copy the bits upside-down.
 733              */
 734             if (bmp->dib->dsBmih.biHeight < 0)
 735             {
 736                 sbits += (srcwidthb * (int)(abs(bmp->dib->dsBmih.biHeight) - 2 * startscan - 1));
 737                 srcwidthb = -srcwidthb;
 738             }
 739             /*Same for the destination.*/
 740             if (height < 0)
 741             {
 742                 dbits = (LPBYTE)bits + (dstwidthb * (lines - 1));
 743                 dstwidthb = -dstwidthb;
 744             }
 745             switch( bpp ) {
 746
 747             case 15:
 748             case 16: /* 16 bpp dstDIB */
 749                 {
 750                     LPWORD dstbits = (LPWORD)dbits;
 751                     WORD rmask = 0x7c00, gmask= 0x03e0, bmask = 0x001f;
 752
 753                     /* FIXME: BI_BITFIELDS not supported yet */
 754
 755                     switch(bmp->dib->dsBm.bmBitsPixel) {
 756
 757                     case 16: /* 16 bpp srcDIB -> 16 bpp dstDIB */
 758                         {
 759                             widthb = min(abs(srcwidthb), abs(dstwidthb));
 760                             /* FIXME: BI_BITFIELDS not supported yet */
 761                             for (y = 0; y < lines; y++, dbits+=dstwidthb, sbits+=srcwidthb)
 762                                 memcpy(dbits, sbits, widthb);
 763                         }
 764                         break;
 765
 766                     case 24: /* 24 bpp srcDIB -> 16 bpp dstDIB */
 767                         {
 768                             LPBYTE srcbits = sbits;
 769
 770                             width = min(srcwidth, dstwidth);
 771                             for( y = 0; y < lines; y++) {
 772                                 for( x = 0; x < width; x++, srcbits += 3)
 773                                     *dstbits++ = ((srcbits[0] >> 3) & bmask) |
 774                                                  (((WORD)srcbits[1] << 2) & gmask) |
 775                                                  (((WORD)srcbits[2] << 7) & rmask);
 776
 777                                 dstbits = (LPWORD)(dbits+=dstwidthb);
 778                                 srcbits = (sbits += srcwidthb);
 779                             }
 780                         }
 781                         break;
 782
 783                     case 32: /* 32 bpp srcDIB -> 16 bpp dstDIB */
 784                         {
 785                             LPDWORD srcbits = (LPDWORD)sbits;
 786                             DWORD val;
 787
 788                             width = min(srcwidth, dstwidth);
 789                             for( y = 0; y < lines; y++) {
 790                                 for( x = 0; x < width; x++ ) {
 791                                     val = *srcbits++;
 792                                     *dstbits++ = (WORD)(((val >> 3) & bmask) | ((val >> 6) & gmask) |
 793                                                        ((val >> 9) & rmask));
 794                                 }
 795                                 dstbits = (LPWORD)(dbits+=dstwidthb);
 796                                 srcbits = (LPDWORD)(sbits+=srcwidthb);
 797                             }
 798                         }
 799                         break;
 800
 801                     default: /* ? bit bmp -> 16 bit DIB */
 802                         FIXME("15/16 bit DIB %d bit bitmap\n",
 803                         bmp->bitmap.bmBitsPixel);
 804                         break;
 805                     }
 806                 }
 807                 break;
 808
 809             case 24: /* 24 bpp dstDIB */
 810                 {
 811                     LPBYTE dstbits = dbits;
 812
 813                     switch(bmp->dib->dsBm.bmBitsPixel) {
 814
 815                     case 16: /* 16 bpp srcDIB -> 24 bpp dstDIB */
 816                         {
 817                             LPWORD srcbits = (LPWORD)sbits;
 818                             WORD val;
 819
 820                             width = min(srcwidth, dstwidth);
 821                             /* FIXME: BI_BITFIELDS not supported yet */
 822                             for( y = 0; y < lines; y++) {
 823                                 for( x = 0; x < width; x++ ) {
 824                                     val = *srcbits++;
 825                                     *dstbits++ = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x07));
 826                                     *dstbits++ = (BYTE)(((val >> 2) & 0xf8) | ((val >> 7) & 0x07));
 827                                     *dstbits++ = (BYTE)(((val >> 7) & 0xf8) | ((val >> 12) & 0x07));
 828                                 }
 829                                 dstbits = dbits+=dstwidthb;
 830                                 srcbits = (LPWORD)(sbits+=srcwidthb);
 831                             }
 832                         }
 833                         break;
 834
 835                     case 24: /* 24 bpp srcDIB -> 24 bpp dstDIB */
 836                         {
 837                             widthb = min(abs(srcwidthb), abs(dstwidthb));
 838                             for (y = 0; y < lines; y++, dbits+=dstwidthb, sbits+=srcwidthb)
 839                                 memcpy(dbits, sbits, widthb);
 840                         }
 841                         break;
 842
 843                     case 32: /* 32 bpp srcDIB -> 24 bpp dstDIB */
 844                         {
 845                             LPBYTE srcbits = sbits;
 846
 847                             width = min(srcwidth, dstwidth);
 848                             for( y = 0; y < lines; y++) {
 849                                 for( x = 0; x < width; x++, srcbits++ ) {
 850                                     *dstbits++ = *srcbits++;
 851                                     *dstbits++ = *srcbits++;
 852                                     *dstbits++ = *srcbits++;
 853                                 }
 854                                 dstbits = dbits+=dstwidthb;
 855                                 srcbits = sbits+=srcwidthb;
 856                             }
 857                         }
 858                         break;
 859
 860                     default: /* ? bit bmp -> 24 bit DIB */
 861                         FIXME("24 bit DIB %d bit bitmap\n",
 862                               bmp->bitmap.bmBitsPixel);
 863                         break;
 864                     }
 865                 }
 866                 break;
 867
 868             case 32: /* 32 bpp dstDIB */
 869                 {
 870                     LPDWORD dstbits = (LPDWORD)dbits;
 871
 872                     /* FIXME: BI_BITFIELDS not supported yet */
 873
 874                     switch(bmp->dib->dsBm.bmBitsPixel) {
 875                         case 16: /* 16 bpp srcDIB -> 32 bpp dstDIB */
 876                         {
 877                             LPWORD srcbits = (LPWORD)sbits;
 878                             DWORD val;
 879
 880                             width = min(srcwidth, dstwidth);
 881                             /* FIXME: BI_BITFIELDS not supported yet */
 882                             for( y = 0; y < lines; y++) {
 883                                 for( x = 0; x < width; x++ ) {
 884                                     val = (DWORD)*srcbits++;
 885                                     *dstbits++ = ((val << 3) & 0xf8) | ((val >> 2) & 0x07) |
 886                                                  ((val << 6) & 0xf800) | ((val << 1) & 0x0700) |
 887                                                  ((val << 9) & 0xf80000) | ((val << 4) & 0x070000);
 888                                 }
 889                                 dstbits=(LPDWORD)(dbits+=dstwidthb);
 890                                 srcbits=(LPWORD)(sbits+=srcwidthb);
 891                             }
 892                         }
 893                         break;
 894
 895                     case 24: /* 24 bpp srcDIB -> 32 bpp dstDIB */
 896                         {
 897                             LPBYTE srcbits = sbits;
 898
 899                             width = min(srcwidth, dstwidth);
 900                             for( y = 0; y < lines; y++) {
 901                                 for( x = 0; x < width; x++, srcbits+=3 )
 902                                     *dstbits++ =  srcbits[0] |
 903                                                  (srcbits[1] <<  8) |
 904                                                  (srcbits[2] << 16);
 905                                 dstbits=(LPDWORD)(dbits+=dstwidthb);
 906                                 srcbits=(sbits+=srcwidthb);
 907                             }
 908                         }
 909                         break;
 910
 911                     case 32: /* 32 bpp srcDIB -> 32 bpp dstDIB */
 912                         {
 913                             widthb = min(abs(srcwidthb), abs(dstwidthb));
 914                             /* FIXME: BI_BITFIELDS not supported yet */
 915                             for (y = 0; y < lines; y++, dbits+=dstwidthb, sbits+=srcwidthb) {
 916                                 memcpy(dbits, sbits, widthb);
 917                             }
 918                         }
 919                         break;
 920
 921                     default: /* ? bit bmp -> 32 bit DIB */
 922                         FIXME("32 bit DIB %d bit bitmap\n",
 923                         bmp->bitmap.bmBitsPixel);
 924                         break;
 925                     }
 926                 }
 927                 break;
 928
 929             default: /* ? bit DIB */
 930                 FIXME("Unsupported DIB depth %d\n", info->bmiHeader.biBitCount);
 931                 break;
 932             }
 933         }
 934         /* Otherwise, get bits from the XImage */
 935         else
 936         {
 937             PHYSDEV physdev = GET_DC_PHYSDEV( dc, pGetDIBits );
 938             if (!BITMAP_SetOwnerDC( hbitmap, physdev )) lines = 0;
 939             else lines = physdev->funcs->pGetDIBits( physdev, hbitmap, startscan,
 940                                                      lines, bits, info, coloruse );
 941         }
 942     }
 943     else lines = abs(height);
 944
 945     /* The knowledge base article Q81498 ("DIBs and Their Uses") states that
 946        if bits == NULL and bpp != 0, only biSizeImage and the color table are
 947        filled in. */
 948     if (!core_header)
 949     {
 950         /* FIXME: biSizeImage should be calculated according to the selected
 951            compression algorithm if biCompression != BI_RGB */
 952         info->bmiHeader.biSizeImage = DIB_GetDIBImageBytes( width, height, bpp );
 953         TRACE("biSizeImage = %d, ", info->bmiHeader.biSizeImage);
 954     }
 955     TRACE("biWidth = %d, biHeight = %d\n", width, height);
 956
 957 done:
 958     release_dc_ptr( dc );
 959     GDI_ReleaseObj( hbitmap );
 960     return lines;
 961 }
 962
 963
 964 /***********************************************************************
 965  *           CreateDIBitmap    (GDI32.@)
 966  *
 967  * Creates a DDB (device dependent bitmap) from a DIB.
 968  * The DDB will have the same color depth as the reference DC.
 969  */
 970 HBITMAP WINAPI CreateDIBitmap( HDC hdc, const BITMAPINFOHEADER *header,
 971                             DWORD init, LPCVOID bits, const BITMAPINFO *data,
 972                             UINT coloruse )
 973 {
 974     HBITMAP handle;
 975     LONG width;
 976     LONG height;
 977     WORD planes, bpp;
 978     DWORD compr, size;
 979
 980     if (!header) return 0;
 981
 982     if (DIB_GetBitmapInfo( header, &width, &height, &planes, &bpp, &compr, &size ) == -1) return 0;
 983
 984     if (width < 0)
 985     {
 986         TRACE("Bitmap has a negative width\n");
 987         return 0;
 988     }
 989
 990     /* Top-down DIBs have a negative height */
 991     if (height < 0) height = -height;
 992
 993     TRACE("hdc=%p, header=%p, init=%u, bits=%p, data=%p, coloruse=%u (bitmap: width=%d, height=%d, bpp=%u, compr=%u)\n",
 994            hdc, header, init, bits, data, coloruse, width, height, bpp, compr);
 995
 996     if (hdc == NULL)
 997         handle = CreateBitmap( width, height, 1, 1, NULL );
 998     else
 999         handle = CreateCompatibleBitmap( hdc, width, height );
1000
1001     if (handle)
1002     {
1003         if (init & CBM_INIT)
1004         {
1005             if (SetDIBits( hdc, handle, 0, height, bits, data, coloruse ) == 0)
1006             {
1007                 DeleteObject( handle );
1008                 handle = 0;
1009             }
1010         }
1011     }
1012
1013     return handle;
1014 }
1015
1016 /* Copy/synthesize RGB palette from BITMAPINFO. Ripped from dlls/winex11.drv/dib.c */
1017 static void DIB_CopyColorTable( DC *dc, BITMAPOBJ *bmp, WORD coloruse, const BITMAPINFO *info )
1018 {
1019     RGBQUAD *colorTable;
1020     unsigned int colors, i;
1021     BOOL core_info = info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER);
1022
1023     if (core_info)
1024     {
1025         colors = 1 << ((const BITMAPCOREINFO*) info)->bmciHeader.bcBitCount;
1026     }
1027     else
1028     {
1029         colors = info->bmiHeader.biClrUsed;
1030         if (!colors) colors = 1 << info->bmiHeader.biBitCount;
1031     }
1032
1033     if (colors > 256) {
1034         ERR("called with >256 colors!\n");
1035         return;
1036     }
1037
1038     if (!(colorTable = HeapAlloc(GetProcessHeap(), 0, colors * sizeof(RGBQUAD) ))) return;
1039
1040     if(coloruse == DIB_RGB_COLORS)
1041     {
1042         if (core_info)
1043         {
1044            /* Convert RGBTRIPLEs to RGBQUADs */
1045            for (i=0; i < colors; i++)
1046            {
1047                colorTable[i].rgbRed   = ((const BITMAPCOREINFO*) info)->bmciColors[i].rgbtRed;
1048                colorTable[i].rgbGreen = ((const BITMAPCOREINFO*) info)->bmciColors[i].rgbtGreen;
1049                colorTable[i].rgbBlue  = ((const BITMAPCOREINFO*) info)->bmciColors[i].rgbtBlue;
1050                colorTable[i].rgbReserved = 0;
1051            }
1052         }
1053         else
1054         {
1055             memcpy(colorTable, (const BYTE*) info + (WORD) info->bmiHeader.biSize, colors * sizeof(RGBQUAD));
1056         }
1057     }
1058     else
1059     {
1060         PALETTEENTRY entries[256];
1061         const WORD *index = (const WORD*) ((const BYTE*) info + (WORD) info->bmiHeader.biSize);
1062         UINT count = GetPaletteEntries( dc->hPalette, 0, colors, entries );
1063
1064         for (i = 0; i < colors; i++, index++)
1065         {
1066             PALETTEENTRY *entry = &entries[*index % count];
1067             colorTable[i].rgbRed = entry->peRed;
1068             colorTable[i].rgbGreen = entry->peGreen;
1069             colorTable[i].rgbBlue = entry->peBlue;
1070             colorTable[i].rgbReserved = 0;
1071         }
1072     }
1073     bmp->color_table = colorTable;
1074     bmp->nb_colors = colors;
1075 }
1076
1077 /***********************************************************************
1078  *           CreateDIBSection    (GDI32.@)
1079  */
1080 HBITMAP WINAPI CreateDIBSection(HDC hdc, CONST BITMAPINFO *bmi, UINT usage,
1081                                 VOID **bits, HANDLE section, DWORD offset)
1082 {
1083     HBITMAP ret = 0;
1084     DC *dc;
1085     BOOL bDesktopDC = FALSE;
1086     DIBSECTION *dib;
1087     BITMAPOBJ *bmp;
1088     int bitmap_type;
1089     LONG width, height;
1090     WORD planes, bpp;
1091     DWORD compression, sizeImage;
1092     void *mapBits = NULL;
1093
1094     if(!bmi){
1095         if(bits) *bits = NULL;
1096         return NULL;
1097     }
1098
1099     if (((bitmap_type = DIB_GetBitmapInfo( &bmi->bmiHeader, &width, &height,
1100                                            &planes, &bpp, &compression, &sizeImage )) == -1))
1101         return 0;
1102
1103     switch (bpp)
1104     {
1105     case 16:
1106     case 32:
1107         if (compression == BI_BITFIELDS) break;
1108         /* fall through */
1109     case 1:
1110     case 4:
1111     case 8:
1112     case 24:
1113         if (compression == BI_RGB) break;
1114         /* fall through */
1115     default:
1116         WARN( "invalid %u bpp compression %u\n", bpp, compression );
1117         return 0;
1118     }
1119
1120     if (!(dib = HeapAlloc( GetProcessHeap(), 0, sizeof(*dib) ))) return 0;
1121
1122     TRACE("format (%d,%d), planes %d, bpp %d, %s, size %d %s\n",
1123           width, height, planes, bpp, compression == BI_BITFIELDS? "BI_BITFIELDS" : "BI_RGB",
1124           sizeImage, usage == DIB_PAL_COLORS? "PAL" : "RGB");
1125
1126     dib->dsBm.bmType       = 0;
1127     dib->dsBm.bmWidth      = width;
1128     dib->dsBm.bmHeight     = height >= 0 ? height : -height;
1129     dib->dsBm.bmWidthBytes = DIB_GetDIBWidthBytes(width, bpp);
1130     dib->dsBm.bmPlanes     = planes;
1131     dib->dsBm.bmBitsPixel  = bpp;
1132     dib->dsBm.bmBits       = NULL;
1133
1134     if (!bitmap_type)  /* core header */
1135     {
1136         /* convert the BITMAPCOREHEADER to a BITMAPINFOHEADER */
1137         dib->dsBmih.biSize = sizeof(BITMAPINFOHEADER);
1138         dib->dsBmih.biWidth = width;
1139         dib->dsBmih.biHeight = height;
1140         dib->dsBmih.biPlanes = planes;
1141         dib->dsBmih.biBitCount = bpp;
1142         dib->dsBmih.biCompression = compression;
1143         dib->dsBmih.biXPelsPerMeter = 0;
1144         dib->dsBmih.biYPelsPerMeter = 0;
1145         dib->dsBmih.biClrUsed = 0;
1146         dib->dsBmih.biClrImportant = 0;
1147     }
1148     else
1149     {
1150         /* truncate extended bitmap headers (BITMAPV4HEADER etc.) */
1151         dib->dsBmih = bmi->bmiHeader;
1152         dib->dsBmih.biSize = sizeof(BITMAPINFOHEADER);
1153     }
1154
1155     /* set number of entries in bmi.bmiColors table */
1156     if( bpp <= 8 )
1157         dib->dsBmih.biClrUsed = 1 << bpp;
1158
1159     dib->dsBmih.biSizeImage = dib->dsBm.bmWidthBytes * dib->dsBm.bmHeight;
1160
1161     /* set dsBitfields values */
1162     dib->dsBitfields[0] = dib->dsBitfields[1] = dib->dsBitfields[2] = 0;
1163
1164     if((bpp == 15 || bpp == 16) && compression == BI_RGB)
1165     {
1166         /* In this case Windows changes biCompression to BI_BITFIELDS,
1167            however for now we won't do this, as there are a lot
1168            of places where BI_BITFIELDS is currently unsupported. */
1169
1170         /* dib->dsBmih.biCompression = compression = BI_BITFIELDS;*/
1171         dib->dsBitfields[0] = 0x7c00;
1172         dib->dsBitfields[1] = 0x03e0;
1173         dib->dsBitfields[2] = 0x001f;
1174     }
1175     else if(compression == BI_BITFIELDS)
1176     {
1177         dib->dsBitfields[0] =  *(const DWORD *)bmi->bmiColors;
1178         dib->dsBitfields[1] =  *((const DWORD *)bmi->bmiColors + 1);
1179         dib->dsBitfields[2] =  *((const DWORD *)bmi->bmiColors + 2);
1180     }
1181
1182     /* get storage location for DIB bits */
1183
1184     if (section)
1185     {
1186         SYSTEM_INFO SystemInfo;
1187         DWORD mapOffset;
1188         INT mapSize;
1189
1190         GetSystemInfo( &SystemInfo );
1191         mapOffset = offset - (offset % SystemInfo.dwAllocationGranularity);
1192         mapSize = dib->dsBmih.biSizeImage + (offset - mapOffset);
1193         mapBits = MapViewOfFile( section, FILE_MAP_ALL_ACCESS, 0, mapOffset, mapSize );
1194         if (mapBits) dib->dsBm.bmBits = (char *)mapBits + (offset - mapOffset);
1195     }
1196     else
1197     {
1198         offset = 0;
1199         dib->dsBm.bmBits = VirtualAlloc( NULL, dib->dsBmih.biSizeImage,
1200                                          MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE );
1201     }
1202     dib->dshSection = section;
1203     dib->dsOffset = offset;
1204
1205     if (!dib->dsBm.bmBits)
1206     {
1207         HeapFree( GetProcessHeap(), 0, dib );
1208         return 0;
1209     }
1210
1211     /* If the reference hdc is null, take the desktop dc */
1212     if (hdc == 0)
1213     {
1214         hdc = CreateCompatibleDC(0);
1215         bDesktopDC = TRUE;
1216     }
1217
1218     if (!(dc = get_dc_ptr( hdc ))) goto error;
1219
1220     /* create Device Dependent Bitmap and add DIB pointer */
1221     ret = CreateBitmap( dib->dsBm.bmWidth, dib->dsBm.bmHeight, 1,
1222                         (bpp == 1) ? 1 : GetDeviceCaps(hdc, BITSPIXEL), NULL );
1223
1224     if (ret && ((bmp = GDI_GetObjPtr(ret, OBJ_BITMAP))))
1225     {
1226         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pCreateDIBSection );
1227         bmp->dib = dib;
1228         bmp->funcs = physdev->funcs;
1229         /* create local copy of DIB palette */
1230         if (bpp <= 8) DIB_CopyColorTable( dc, bmp, usage, bmi );
1231         GDI_ReleaseObj( ret );
1232
1233         if (!physdev->funcs->pCreateDIBSection( physdev, ret, bmi, usage ))
1234         {
1235             DeleteObject( ret );
1236             ret = 0;
1237         }
1238     }
1239
1240     release_dc_ptr( dc );
1241     if (bDesktopDC) DeleteDC( hdc );
1242     if (ret && bits) *bits = dib->dsBm.bmBits;
1243     return ret;
1244
1245 error:
1246     if (bDesktopDC) DeleteDC( hdc );
1247     if (section) UnmapViewOfFile( mapBits );
1248     else if (!offset) VirtualFree( dib->dsBm.bmBits, 0, MEM_RELEASE );
1249     HeapFree( GetProcessHeap(), 0, dib );
1250     return 0;
1251 }