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 static const RGBQUAD DefLogPaletteQuads[20] = { /* Copy of Default Logical Palette */
 419 /* rgbBlue, rgbGreen, rgbRed, rgbReserved */
 420     { 0x00, 0x00, 0x00, 0x00 },
 421     { 0x00, 0x00, 0x80, 0x00 },
 422     { 0x00, 0x80, 0x00, 0x00 },
 423     { 0x00, 0x80, 0x80, 0x00 },
 424     { 0x80, 0x00, 0x00, 0x00 },
 425     { 0x80, 0x00, 0x80, 0x00 },
 426     { 0x80, 0x80, 0x00, 0x00 },
 427     { 0xc0, 0xc0, 0xc0, 0x00 },
 428     { 0xc0, 0xdc, 0xc0, 0x00 },
 429     { 0xf0, 0xca, 0xa6, 0x00 },
 430     { 0xf0, 0xfb, 0xff, 0x00 },
 431     { 0xa4, 0xa0, 0xa0, 0x00 },
 432     { 0x80, 0x80, 0x80, 0x00 },
 433     { 0x00, 0x00, 0xff, 0x00 },
 434     { 0x00, 0xff, 0x00, 0x00 },
 435     { 0x00, 0xff, 0xff, 0x00 },
 436     { 0xff, 0x00, 0x00, 0x00 },
 437     { 0xff, 0x00, 0xff, 0x00 },
 438     { 0xff, 0xff, 0x00, 0x00 },
 439     { 0xff, 0xff, 0xff, 0x00 }
 440 };
 441
 442 static const DWORD bit_fields_888[3] = {0xff0000, 0x00ff00, 0x0000ff};
 443 static const DWORD bit_fields_565[3] = {0xf800, 0x07e0, 0x001f};
 444 static const DWORD bit_fields_555[3] = {0x7c00, 0x03e0, 0x001f};
 445
 446 /******************************************************************************
 447  * GetDIBits [GDI32.@]
 448  *
 449  * Retrieves bits of bitmap and copies to buffer.
 450  *
 451  * RETURNS
 452  *    Success: Number of scan lines copied from bitmap
 453  *    Failure: 0
 454  */
 455 INT WINAPI GetDIBits(
 456     HDC hdc,         /* [in]  Handle to device context */
 457     HBITMAP hbitmap, /* [in]  Handle to bitmap */
 458     UINT startscan,  /* [in]  First scan line to set in dest bitmap */
 459     UINT lines,      /* [in]  Number of scan lines to copy */
 460     LPVOID bits,       /* [out] Address of array for bitmap bits */
 461     BITMAPINFO * info, /* [out] Address of structure with bitmap data */
 462     UINT coloruse)   /* [in]  RGB or palette index */
 463 {
 464     DC * dc;
 465     BITMAPOBJ * bmp;
 466     int i;
 467     int bitmap_type;
 468     BOOL core_header;
 469     LONG width;
 470     LONG height;
 471     WORD planes, bpp;
 472     DWORD compr, size;
 473     void* colorPtr;
 474     RGBQUAD quad_buf[256];
 475     RGBQUAD* rgbQuads = quad_buf;
 476
 477     if (!info) return 0;
 478
 479     bitmap_type = DIB_GetBitmapInfo( &info->bmiHeader, &width, &height, &planes, &bpp, &compr, &size);
 480     if (bitmap_type == -1)
 481     {
 482         ERR("Invalid bitmap format\n");
 483         return 0;
 484     }
 485     core_header = (bitmap_type == 0);
 486     if (!(dc = get_dc_ptr( hdc )))
 487     {
 488         SetLastError( ERROR_INVALID_PARAMETER );
 489         return 0;
 490     }
 491     update_dc( dc );
 492     if (!(bmp = GDI_GetObjPtr( hbitmap, OBJ_BITMAP )))
 493     {
 494         release_dc_ptr( dc );
 495         return 0;
 496     }
 497
 498     colorPtr = (LPBYTE) info + (WORD) info->bmiHeader.biSize;
 499     if(!core_header) rgbQuads = colorPtr;
 500
 501     /* Transfer color info */
 502
 503     switch (bpp)
 504     {
 505     case 0:  /* query bitmap info only */
 506         if (core_header)
 507         {
 508             BITMAPCOREHEADER* coreheader = (BITMAPCOREHEADER*) info;
 509             coreheader->bcWidth = bmp->bitmap.bmWidth;
 510             coreheader->bcHeight = bmp->bitmap.bmHeight;
 511             coreheader->bcPlanes = 1;
 512             coreheader->bcBitCount = bmp->bitmap.bmBitsPixel;
 513         }
 514         else
 515         {
 516             info->bmiHeader.biWidth = bmp->bitmap.bmWidth;
 517             info->bmiHeader.biHeight = bmp->bitmap.bmHeight;
 518             info->bmiHeader.biPlanes = 1;
 519             info->bmiHeader.biSizeImage =
 520                 DIB_GetDIBImageBytes( bmp->bitmap.bmWidth,
 521                                       bmp->bitmap.bmHeight,
 522                                       bmp->bitmap.bmBitsPixel );
 523             if (bmp->dib)
 524             {
 525                 info->bmiHeader.biBitCount = bmp->dib->dsBm.bmBitsPixel;
 526                 switch (bmp->dib->dsBm.bmBitsPixel)
 527                 {
 528                 case 16:
 529                 case 32:
 530                     info->bmiHeader.biCompression = BI_BITFIELDS;
 531                     break;
 532                 default:
 533                     info->bmiHeader.biCompression = BI_RGB;
 534                     break;
 535                 }
 536             }
 537             else
 538             {
 539                 info->bmiHeader.biCompression = (bmp->bitmap.bmBitsPixel > 8) ? BI_BITFIELDS : BI_RGB;
 540                 info->bmiHeader.biBitCount = bmp->bitmap.bmBitsPixel;
 541             }
 542             info->bmiHeader.biXPelsPerMeter = 0;
 543             info->bmiHeader.biYPelsPerMeter = 0;
 544             info->bmiHeader.biClrUsed = 0;
 545             info->bmiHeader.biClrImportant = 0;
 546
 547             /* Windows 2000 doesn't touch the additional struct members if
 548                it's a BITMAPV4HEADER or a BITMAPV5HEADER */
 549         }
 550         lines = abs(bmp->bitmap.bmHeight);
 551         goto done;
 552
 553     case 1:
 554     case 4:
 555     case 8:
 556     {
 557         unsigned int colors = 1 << bpp;
 558
 559         if (!core_header) info->bmiHeader.biClrUsed = 0;
 560
 561         if (coloruse == DIB_PAL_COLORS)
 562         {
 563             WORD *index = colorPtr;
 564             for (i = 0; i < colors; i++, index++)
 565                 *index = i;
 566
 567             break;
 568         }
 569
 570         /* If the bitmap object already has a dib section at the
 571            same color depth then get the color map from it */
 572
 573         if (bmp->dib && bmp->dib->dsBm.bmBitsPixel == bpp)
 574         {
 575             colors = min( colors, bmp->nb_colors );
 576
 577             if (!core_header && colors != 1 << bpp) info->bmiHeader.biClrUsed = colors;
 578
 579             memcpy(rgbQuads, bmp->color_table, colors * sizeof(RGBQUAD));
 580         }
 581
 582         /* For color DDBs in native depth (mono DDBs always have a black/white palette):
 583            Generate the color map from the selected palette */
 584
 585         else if (bpp > 1 && bpp == bmp->bitmap.bmBitsPixel)
 586         {
 587             PALETTEENTRY palEntry[256];
 588
 589             memset( palEntry, 0, sizeof(palEntry) );
 590             if (!GetPaletteEntries( dc->hPalette, 0, colors, palEntry ))
 591             {
 592                 release_dc_ptr( dc );
 593                 GDI_ReleaseObj( hbitmap );
 594                 return 0;
 595             }
 596             for (i = 0; i < colors; i++)
 597             {
 598                 rgbQuads[i].rgbRed      = palEntry[i].peRed;
 599                 rgbQuads[i].rgbGreen    = palEntry[i].peGreen;
 600                 rgbQuads[i].rgbBlue     = palEntry[i].peBlue;
 601                 rgbQuads[i].rgbReserved = 0;
 602             }
 603         }
 604         else
 605         {
 606             switch (bpp)
 607             {
 608             case 1:
 609                 rgbQuads[0].rgbRed = rgbQuads[0].rgbGreen = rgbQuads[0].rgbBlue = 0;
 610                 rgbQuads[0].rgbReserved = 0;
 611                 rgbQuads[1].rgbRed = rgbQuads[1].rgbGreen = rgbQuads[1].rgbBlue = 0xff;
 612                 rgbQuads[1].rgbReserved = 0;
 613                 break;
 614
 615             case 4:
 616                 /* The EGA palette is the first and last 8 colours of the default palette
 617                    with the innermost pair swapped */
 618                 memcpy(rgbQuads,     DefLogPaletteQuads,      7 * sizeof(RGBQUAD));
 619                 memcpy(rgbQuads + 7, DefLogPaletteQuads + 12, 1 * sizeof(RGBQUAD));
 620                 memcpy(rgbQuads + 8, DefLogPaletteQuads +  7, 1 * sizeof(RGBQUAD));
 621                 memcpy(rgbQuads + 9, DefLogPaletteQuads + 13, 7 * sizeof(RGBQUAD));
 622                 break;
 623
 624             case 8:
 625                 memcpy(rgbQuads, DefLogPaletteQuads, 10 * sizeof(RGBQUAD));
 626                 memcpy(rgbQuads + 246, DefLogPaletteQuads + 10, 10 * sizeof(RGBQUAD));
 627                 for (i = 10; i < 246; i++)
 628                 {
 629                     rgbQuads[i].rgbRed      = (i & 0x07) << 5;
 630                     rgbQuads[i].rgbGreen    = (i & 0x38) << 2;
 631                     rgbQuads[i].rgbBlue     =  i & 0xc0;
 632                     rgbQuads[i].rgbReserved = 0;
 633                 }
 634             }
 635         }
 636
 637         if(core_header)
 638         {
 639             RGBTRIPLE *triple = (RGBTRIPLE *)colorPtr;
 640             for (i = 0; i < colors; i++)
 641             {
 642                 triple[i].rgbtRed   = rgbQuads[i].rgbRed;
 643                 triple[i].rgbtGreen = rgbQuads[i].rgbGreen;
 644                 triple[i].rgbtBlue  = rgbQuads[i].rgbBlue;
 645             }
 646         }
 647
 648         break;
 649     }
 650
 651     case 15:
 652         if (info->bmiHeader.biCompression == BI_BITFIELDS)
 653             memcpy( info->bmiColors, bit_fields_555, sizeof(bit_fields_555) );
 654         break;
 655
 656     case 16:
 657         if (info->bmiHeader.biCompression == BI_BITFIELDS)
 658         {
 659             if (bmp->dib)
 660             {
 661                 if (bmp->dib->dsBmih.biCompression == BI_BITFIELDS && bmp->dib->dsBmih.biBitCount == bpp)
 662                     memcpy( info->bmiColors, bmp->dib->dsBitfields, 3 * sizeof(DWORD) );
 663                 else
 664                     memcpy( info->bmiColors, bit_fields_555, sizeof(bit_fields_555) );
 665             }
 666             else
 667                 memcpy( info->bmiColors, bit_fields_565, sizeof(bit_fields_565) );
 668         }
 669         break;
 670
 671     case 24:
 672     case 32:
 673         if (info->bmiHeader.biCompression == BI_BITFIELDS)
 674         {
 675             if (bmp->dib && bmp->dib->dsBmih.biCompression == BI_BITFIELDS && bmp->dib->dsBmih.biBitCount == bpp)
 676                 memcpy( info->bmiColors, bmp->dib->dsBitfields, 3 * sizeof(DWORD) );
 677             else
 678                 memcpy( info->bmiColors, bit_fields_888, sizeof(bit_fields_888) );
 679         }
 680         break;
 681     }
 682
 683     if (bits && lines)
 684     {
 685         /* If the bitmap object already have a dib section that contains image data, get the bits from it */
 686         if(bmp->dib && bmp->dib->dsBm.bmBitsPixel >= 15 && bpp >= 15)
 687         {
 688             /*FIXME: Only RGB dibs supported for now */
 689             unsigned int srcwidth = bmp->dib->dsBm.bmWidth;
 690             int srcwidthb = bmp->dib->dsBm.bmWidthBytes;
 691             unsigned int dstwidth = width;
 692             int dstwidthb = DIB_GetDIBWidthBytes( width, bpp );
 693             LPBYTE dbits = bits, sbits = (LPBYTE) bmp->dib->dsBm.bmBits + (startscan * srcwidthb);
 694             unsigned int x, y, width, widthb;
 695
 696             /*
 697              * If copying from a top-down source bitmap, move the source
 698              * pointer to the end of the source bitmap and negate the width
 699              * so that we copy the bits upside-down.
 700              */
 701             if (bmp->dib->dsBmih.biHeight < 0)
 702             {
 703                 sbits += (srcwidthb * (int)(abs(bmp->dib->dsBmih.biHeight) - 2 * startscan - 1));
 704                 srcwidthb = -srcwidthb;
 705             }
 706             /*Same for the destination.*/
 707             if (height < 0)
 708             {
 709                 dbits = (LPBYTE)bits + (dstwidthb * (lines - 1));
 710                 dstwidthb = -dstwidthb;
 711             }
 712             switch( bpp ) {
 713
 714             case 15:
 715             case 16: /* 16 bpp dstDIB */
 716                 {
 717                     LPWORD dstbits = (LPWORD)dbits;
 718                     WORD rmask = 0x7c00, gmask= 0x03e0, bmask = 0x001f;
 719
 720                     /* FIXME: BI_BITFIELDS not supported yet */
 721
 722                     switch(bmp->dib->dsBm.bmBitsPixel) {
 723
 724                     case 16: /* 16 bpp srcDIB -> 16 bpp dstDIB */
 725                         {
 726                             widthb = min(abs(srcwidthb), abs(dstwidthb));
 727                             /* FIXME: BI_BITFIELDS not supported yet */
 728                             for (y = 0; y < lines; y++, dbits+=dstwidthb, sbits+=srcwidthb)
 729                                 memcpy(dbits, sbits, widthb);
 730                         }
 731                         break;
 732
 733                     case 24: /* 24 bpp srcDIB -> 16 bpp dstDIB */
 734                         {
 735                             LPBYTE srcbits = sbits;
 736
 737                             width = min(srcwidth, dstwidth);
 738                             for( y = 0; y < lines; y++) {
 739                                 for( x = 0; x < width; x++, srcbits += 3)
 740                                     *dstbits++ = ((srcbits[0] >> 3) & bmask) |
 741                                                  (((WORD)srcbits[1] << 2) & gmask) |
 742                                                  (((WORD)srcbits[2] << 7) & rmask);
 743
 744                                 dstbits = (LPWORD)(dbits+=dstwidthb);
 745                                 srcbits = (sbits += srcwidthb);
 746                             }
 747                         }
 748                         break;
 749
 750                     case 32: /* 32 bpp srcDIB -> 16 bpp dstDIB */
 751                         {
 752                             LPDWORD srcbits = (LPDWORD)sbits;
 753                             DWORD val;
 754
 755                             width = min(srcwidth, dstwidth);
 756                             for( y = 0; y < lines; y++) {
 757                                 for( x = 0; x < width; x++ ) {
 758                                     val = *srcbits++;
 759                                     *dstbits++ = (WORD)(((val >> 3) & bmask) | ((val >> 6) & gmask) |
 760                                                        ((val >> 9) & rmask));
 761                                 }
 762                                 dstbits = (LPWORD)(dbits+=dstwidthb);
 763                                 srcbits = (LPDWORD)(sbits+=srcwidthb);
 764                             }
 765                         }
 766                         break;
 767
 768                     default: /* ? bit bmp -> 16 bit DIB */
 769                         FIXME("15/16 bit DIB %d bit bitmap\n",
 770                         bmp->bitmap.bmBitsPixel);
 771                         break;
 772                     }
 773                 }
 774                 break;
 775
 776             case 24: /* 24 bpp dstDIB */
 777                 {
 778                     LPBYTE dstbits = dbits;
 779
 780                     switch(bmp->dib->dsBm.bmBitsPixel) {
 781
 782                     case 16: /* 16 bpp srcDIB -> 24 bpp dstDIB */
 783                         {
 784                             LPWORD srcbits = (LPWORD)sbits;
 785                             WORD val;
 786
 787                             width = min(srcwidth, dstwidth);
 788                             /* FIXME: BI_BITFIELDS not supported yet */
 789                             for( y = 0; y < lines; y++) {
 790                                 for( x = 0; x < width; x++ ) {
 791                                     val = *srcbits++;
 792                                     *dstbits++ = (BYTE)(((val << 3) & 0xf8) | ((val >> 2) & 0x07));
 793                                     *dstbits++ = (BYTE)(((val >> 2) & 0xf8) | ((val >> 7) & 0x07));
 794                                     *dstbits++ = (BYTE)(((val >> 7) & 0xf8) | ((val >> 12) & 0x07));
 795                                 }
 796                                 dstbits = dbits+=dstwidthb;
 797                                 srcbits = (LPWORD)(sbits+=srcwidthb);
 798                             }
 799                         }
 800                         break;
 801
 802                     case 24: /* 24 bpp srcDIB -> 24 bpp dstDIB */
 803                         {
 804                             widthb = min(abs(srcwidthb), abs(dstwidthb));
 805                             for (y = 0; y < lines; y++, dbits+=dstwidthb, sbits+=srcwidthb)
 806                                 memcpy(dbits, sbits, widthb);
 807                         }
 808                         break;
 809
 810                     case 32: /* 32 bpp srcDIB -> 24 bpp dstDIB */
 811                         {
 812                             LPBYTE srcbits = sbits;
 813
 814                             width = min(srcwidth, dstwidth);
 815                             for( y = 0; y < lines; y++) {
 816                                 for( x = 0; x < width; x++, srcbits++ ) {
 817                                     *dstbits++ = *srcbits++;
 818                                     *dstbits++ = *srcbits++;
 819                                     *dstbits++ = *srcbits++;
 820                                 }
 821                                 dstbits = dbits+=dstwidthb;
 822                                 srcbits = sbits+=srcwidthb;
 823                             }
 824                         }
 825                         break;
 826
 827                     default: /* ? bit bmp -> 24 bit DIB */
 828                         FIXME("24 bit DIB %d bit bitmap\n",
 829                               bmp->bitmap.bmBitsPixel);
 830                         break;
 831                     }
 832                 }
 833                 break;
 834
 835             case 32: /* 32 bpp dstDIB */
 836                 {
 837                     LPDWORD dstbits = (LPDWORD)dbits;
 838
 839                     /* FIXME: BI_BITFIELDS not supported yet */
 840
 841                     switch(bmp->dib->dsBm.bmBitsPixel) {
 842                         case 16: /* 16 bpp srcDIB -> 32 bpp dstDIB */
 843                         {
 844                             LPWORD srcbits = (LPWORD)sbits;
 845                             DWORD val;
 846
 847                             width = min(srcwidth, dstwidth);
 848                             /* FIXME: BI_BITFIELDS not supported yet */
 849                             for( y = 0; y < lines; y++) {
 850                                 for( x = 0; x < width; x++ ) {
 851                                     val = (DWORD)*srcbits++;
 852                                     *dstbits++ = ((val << 3) & 0xf8) | ((val >> 2) & 0x07) |
 853                                                  ((val << 6) & 0xf800) | ((val << 1) & 0x0700) |
 854                                                  ((val << 9) & 0xf80000) | ((val << 4) & 0x070000);
 855                                 }
 856                                 dstbits=(LPDWORD)(dbits+=dstwidthb);
 857                                 srcbits=(LPWORD)(sbits+=srcwidthb);
 858                             }
 859                         }
 860                         break;
 861
 862                     case 24: /* 24 bpp srcDIB -> 32 bpp dstDIB */
 863                         {
 864                             LPBYTE srcbits = sbits;
 865
 866                             width = min(srcwidth, dstwidth);
 867                             for( y = 0; y < lines; y++) {
 868                                 for( x = 0; x < width; x++, srcbits+=3 )
 869                                     *dstbits++ =  srcbits[0] |
 870                                                  (srcbits[1] <<  8) |
 871                                                  (srcbits[2] << 16);
 872                                 dstbits=(LPDWORD)(dbits+=dstwidthb);
 873                                 srcbits=(sbits+=srcwidthb);
 874                             }
 875                         }
 876                         break;
 877
 878                     case 32: /* 32 bpp srcDIB -> 32 bpp dstDIB */
 879                         {
 880                             widthb = min(abs(srcwidthb), abs(dstwidthb));
 881                             /* FIXME: BI_BITFIELDS not supported yet */
 882                             for (y = 0; y < lines; y++, dbits+=dstwidthb, sbits+=srcwidthb) {
 883                                 memcpy(dbits, sbits, widthb);
 884                             }
 885                         }
 886                         break;
 887
 888                     default: /* ? bit bmp -> 32 bit DIB */
 889                         FIXME("32 bit DIB %d bit bitmap\n",
 890                         bmp->bitmap.bmBitsPixel);
 891                         break;
 892                     }
 893                 }
 894                 break;
 895
 896             default: /* ? bit DIB */
 897                 FIXME("Unsupported DIB depth %d\n", info->bmiHeader.biBitCount);
 898                 break;
 899             }
 900         }
 901         /* Otherwise, get bits from the XImage */
 902         else
 903         {
 904             PHYSDEV physdev = GET_DC_PHYSDEV( dc, pGetDIBits );
 905             if (!BITMAP_SetOwnerDC( hbitmap, physdev )) lines = 0;
 906             else lines = physdev->funcs->pGetDIBits( physdev, hbitmap, startscan,
 907                                                      lines, bits, info, coloruse );
 908         }
 909     }
 910     else lines = abs(height);
 911
 912     /* The knowledge base article Q81498 ("DIBs and Their Uses") states that
 913        if bits == NULL and bpp != 0, only biSizeImage and the color table are
 914        filled in. */
 915     if (!core_header)
 916     {
 917         /* FIXME: biSizeImage should be calculated according to the selected
 918            compression algorithm if biCompression != BI_RGB */
 919         info->bmiHeader.biSizeImage = DIB_GetDIBImageBytes( width, height, bpp );
 920         TRACE("biSizeImage = %d, ", info->bmiHeader.biSizeImage);
 921     }
 922     TRACE("biWidth = %d, biHeight = %d\n", width, height);
 923
 924 done:
 925     release_dc_ptr( dc );
 926     GDI_ReleaseObj( hbitmap );
 927     return lines;
 928 }
 929
 930
 931 /***********************************************************************
 932  *           CreateDIBitmap    (GDI32.@)
 933  *
 934  * Creates a DDB (device dependent bitmap) from a DIB.
 935  * The DDB will have the same color depth as the reference DC.
 936  */
 937 HBITMAP WINAPI CreateDIBitmap( HDC hdc, const BITMAPINFOHEADER *header,
 938                             DWORD init, LPCVOID bits, const BITMAPINFO *data,
 939                             UINT coloruse )
 940 {
 941     HBITMAP handle;
 942     LONG width;
 943     LONG height;
 944     WORD planes, bpp;
 945     DWORD compr, size;
 946
 947     if (!header) return 0;
 948
 949     if (DIB_GetBitmapInfo( header, &width, &height, &planes, &bpp, &compr, &size ) == -1) return 0;
 950
 951     if (width < 0)
 952     {
 953         TRACE("Bitmap has a negative width\n");
 954         return 0;
 955     }
 956
 957     /* Top-down DIBs have a negative height */
 958     if (height < 0) height = -height;
 959
 960     TRACE("hdc=%p, header=%p, init=%u, bits=%p, data=%p, coloruse=%u (bitmap: width=%d, height=%d, bpp=%u, compr=%u)\n",
 961            hdc, header, init, bits, data, coloruse, width, height, bpp, compr);
 962
 963     if (hdc == NULL)
 964         handle = CreateBitmap( width, height, 1, 1, NULL );
 965     else
 966         handle = CreateCompatibleBitmap( hdc, width, height );
 967
 968     if (handle)
 969     {
 970         if (init & CBM_INIT)
 971         {
 972             if (SetDIBits( hdc, handle, 0, height, bits, data, coloruse ) == 0)
 973             {
 974                 DeleteObject( handle );
 975                 handle = 0;
 976             }
 977         }
 978     }
 979
 980     return handle;
 981 }
 982
 983 /* Copy/synthesize RGB palette from BITMAPINFO. Ripped from dlls/winex11.drv/dib.c */
 984 static void DIB_CopyColorTable( DC *dc, BITMAPOBJ *bmp, WORD coloruse, const BITMAPINFO *info )
 985 {
 986     RGBQUAD *colorTable;
 987     unsigned int colors, i;
 988     BOOL core_info = info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER);
 989
 990     if (core_info)
 991     {
 992         colors = 1 << ((const BITMAPCOREINFO*) info)->bmciHeader.bcBitCount;
 993     }
 994     else
 995     {
 996         colors = info->bmiHeader.biClrUsed;
 997         if (!colors) colors = 1 << info->bmiHeader.biBitCount;
 998     }
 999
1000     if (colors > 256) {
1001         ERR("called with >256 colors!\n");
1002         return;
1003     }
1004
1005     if (!(colorTable = HeapAlloc(GetProcessHeap(), 0, colors * sizeof(RGBQUAD) ))) return;
1006
1007     if(coloruse == DIB_RGB_COLORS)
1008     {
1009         if (core_info)
1010         {
1011            /* Convert RGBTRIPLEs to RGBQUADs */
1012            for (i=0; i < colors; i++)
1013            {
1014                colorTable[i].rgbRed   = ((const BITMAPCOREINFO*) info)->bmciColors[i].rgbtRed;
1015                colorTable[i].rgbGreen = ((const BITMAPCOREINFO*) info)->bmciColors[i].rgbtGreen;
1016                colorTable[i].rgbBlue  = ((const BITMAPCOREINFO*) info)->bmciColors[i].rgbtBlue;
1017                colorTable[i].rgbReserved = 0;
1018            }
1019         }
1020         else
1021         {
1022             memcpy(colorTable, (const BYTE*) info + (WORD) info->bmiHeader.biSize, colors * sizeof(RGBQUAD));
1023         }
1024     }
1025     else
1026     {
1027         PALETTEENTRY entries[256];
1028         const WORD *index = (const WORD*) ((const BYTE*) info + (WORD) info->bmiHeader.biSize);
1029         UINT count = GetPaletteEntries( dc->hPalette, 0, colors, entries );
1030
1031         for (i = 0; i < colors; i++, index++)
1032         {
1033             PALETTEENTRY *entry = &entries[*index % count];
1034             colorTable[i].rgbRed = entry->peRed;
1035             colorTable[i].rgbGreen = entry->peGreen;
1036             colorTable[i].rgbBlue = entry->peBlue;
1037             colorTable[i].rgbReserved = 0;
1038         }
1039     }
1040     bmp->color_table = colorTable;
1041     bmp->nb_colors = colors;
1042 }
1043
1044 /***********************************************************************
1045  *           CreateDIBSection    (GDI32.@)
1046  */
1047 HBITMAP WINAPI CreateDIBSection(HDC hdc, CONST BITMAPINFO *bmi, UINT usage,
1048                                 VOID **bits, HANDLE section, DWORD offset)
1049 {
1050     HBITMAP ret = 0;
1051     DC *dc;
1052     BOOL bDesktopDC = FALSE;
1053     DIBSECTION *dib;
1054     BITMAPOBJ *bmp;
1055     int bitmap_type;
1056     LONG width, height;
1057     WORD planes, bpp;
1058     DWORD compression, sizeImage;
1059     void *mapBits = NULL;
1060
1061     if(!bmi){
1062         if(bits) *bits = NULL;
1063         return NULL;
1064     }
1065
1066     if (((bitmap_type = DIB_GetBitmapInfo( &bmi->bmiHeader, &width, &height,
1067                                            &planes, &bpp, &compression, &sizeImage )) == -1))
1068         return 0;
1069
1070     switch (bpp)
1071     {
1072     case 16:
1073     case 32:
1074         if (compression == BI_BITFIELDS) break;
1075         /* fall through */
1076     case 1:
1077     case 4:
1078     case 8:
1079     case 24:
1080         if (compression == BI_RGB) break;
1081         /* fall through */
1082     default:
1083         WARN( "invalid %u bpp compression %u\n", bpp, compression );
1084         return 0;
1085     }
1086
1087     if (!(dib = HeapAlloc( GetProcessHeap(), 0, sizeof(*dib) ))) return 0;
1088
1089     TRACE("format (%d,%d), planes %d, bpp %d, %s, size %d %s\n",
1090           width, height, planes, bpp, compression == BI_BITFIELDS? "BI_BITFIELDS" : "BI_RGB",
1091           sizeImage, usage == DIB_PAL_COLORS? "PAL" : "RGB");
1092
1093     dib->dsBm.bmType       = 0;
1094     dib->dsBm.bmWidth      = width;
1095     dib->dsBm.bmHeight     = height >= 0 ? height : -height;
1096     dib->dsBm.bmWidthBytes = DIB_GetDIBWidthBytes(width, bpp);
1097     dib->dsBm.bmPlanes     = planes;
1098     dib->dsBm.bmBitsPixel  = bpp;
1099     dib->dsBm.bmBits       = NULL;
1100
1101     if (!bitmap_type)  /* core header */
1102     {
1103         /* convert the BITMAPCOREHEADER to a BITMAPINFOHEADER */
1104         dib->dsBmih.biSize = sizeof(BITMAPINFOHEADER);
1105         dib->dsBmih.biWidth = width;
1106         dib->dsBmih.biHeight = height;
1107         dib->dsBmih.biPlanes = planes;
1108         dib->dsBmih.biBitCount = bpp;
1109         dib->dsBmih.biCompression = compression;
1110         dib->dsBmih.biXPelsPerMeter = 0;
1111         dib->dsBmih.biYPelsPerMeter = 0;
1112         dib->dsBmih.biClrUsed = 0;
1113         dib->dsBmih.biClrImportant = 0;
1114     }
1115     else
1116     {
1117         /* truncate extended bitmap headers (BITMAPV4HEADER etc.) */
1118         dib->dsBmih = bmi->bmiHeader;
1119         dib->dsBmih.biSize = sizeof(BITMAPINFOHEADER);
1120     }
1121
1122     /* set number of entries in bmi.bmiColors table */
1123     if( bpp <= 8 )
1124         dib->dsBmih.biClrUsed = 1 << bpp;
1125
1126     dib->dsBmih.biSizeImage = dib->dsBm.bmWidthBytes * dib->dsBm.bmHeight;
1127
1128     /* set dsBitfields values */
1129     dib->dsBitfields[0] = dib->dsBitfields[1] = dib->dsBitfields[2] = 0;
1130
1131     if((bpp == 15 || bpp == 16) && compression == BI_RGB)
1132     {
1133         /* In this case Windows changes biCompression to BI_BITFIELDS,
1134            however for now we won't do this, as there are a lot
1135            of places where BI_BITFIELDS is currently unsupported. */
1136
1137         /* dib->dsBmih.biCompression = compression = BI_BITFIELDS;*/
1138         dib->dsBitfields[0] = 0x7c00;
1139         dib->dsBitfields[1] = 0x03e0;
1140         dib->dsBitfields[2] = 0x001f;
1141     }
1142     else if(compression == BI_BITFIELDS)
1143     {
1144         dib->dsBitfields[0] =  *(const DWORD *)bmi->bmiColors;
1145         dib->dsBitfields[1] =  *((const DWORD *)bmi->bmiColors + 1);
1146         dib->dsBitfields[2] =  *((const DWORD *)bmi->bmiColors + 2);
1147     }
1148
1149     /* get storage location for DIB bits */
1150
1151     if (section)
1152     {
1153         SYSTEM_INFO SystemInfo;
1154         DWORD mapOffset;
1155         INT mapSize;
1156
1157         GetSystemInfo( &SystemInfo );
1158         mapOffset = offset - (offset % SystemInfo.dwAllocationGranularity);
1159         mapSize = dib->dsBmih.biSizeImage + (offset - mapOffset);
1160         mapBits = MapViewOfFile( section, FILE_MAP_ALL_ACCESS, 0, mapOffset, mapSize );
1161         if (mapBits) dib->dsBm.bmBits = (char *)mapBits + (offset - mapOffset);
1162     }
1163     else
1164     {
1165         offset = 0;
1166         dib->dsBm.bmBits = VirtualAlloc( NULL, dib->dsBmih.biSizeImage,
1167                                          MEM_RESERVE|MEM_COMMIT, PAGE_READWRITE );
1168     }
1169     dib->dshSection = section;
1170     dib->dsOffset = offset;
1171
1172     if (!dib->dsBm.bmBits)
1173     {
1174         HeapFree( GetProcessHeap(), 0, dib );
1175         return 0;
1176     }
1177
1178     /* If the reference hdc is null, take the desktop dc */
1179     if (hdc == 0)
1180     {
1181         hdc = CreateCompatibleDC(0);
1182         bDesktopDC = TRUE;
1183     }
1184
1185     if (!(dc = get_dc_ptr( hdc ))) goto error;
1186
1187     /* create Device Dependent Bitmap and add DIB pointer */
1188     ret = CreateBitmap( dib->dsBm.bmWidth, dib->dsBm.bmHeight, 1,
1189                         (bpp == 1) ? 1 : GetDeviceCaps(hdc, BITSPIXEL), NULL );
1190
1191     if (ret && ((bmp = GDI_GetObjPtr(ret, OBJ_BITMAP))))
1192     {
1193         PHYSDEV physdev = GET_DC_PHYSDEV( dc, pCreateDIBSection );
1194         bmp->dib = dib;
1195         bmp->funcs = physdev->funcs;
1196         /* create local copy of DIB palette */
1197         if (bpp <= 8) DIB_CopyColorTable( dc, bmp, usage, bmi );
1198         GDI_ReleaseObj( ret );
1199
1200         if (!physdev->funcs->pCreateDIBSection( physdev, ret, bmi, usage ))
1201         {
1202             DeleteObject( ret );
1203             ret = 0;
1204         }
1205     }
1206
1207     release_dc_ptr( dc );
1208     if (bDesktopDC) DeleteDC( hdc );
1209     if (ret && bits) *bits = dib->dsBm.bmBits;
1210     return ret;
1211
1212 error:
1213     if (bDesktopDC) DeleteDC( hdc );
1214     if (section) UnmapViewOfFile( mapBits );
1215     else if (!offset) VirtualFree( dib->dsBm.bmBits, 0, MEM_RELEASE );
1216     HeapFree( GetProcessHeap(), 0, dib );
1217     return 0;
1218 }