dlls/win32u/bitmap.c

   1 /*
   2  * GDI bitmap objects
   3  *
   4  * Copyright 1993 Alexandre Julliard
   5  *           1998 Huw D M Davies
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #if 0
  23 #pragma makedep unix
  24 #endif
  25
  26 #include <stdarg.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "wingdi.h"
  33 #include "ntgdi_private.h"
  34 #include "wine/debug.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(bitmap);
  37
  38
  39 static INT BITMAP_GetObject( HGDIOBJ handle, INT count, LPVOID buffer );
  40 static BOOL BITMAP_DeleteObject( HGDIOBJ handle );
  41
  42 static const struct gdi_obj_funcs bitmap_funcs =
  43 {
  44     BITMAP_GetObject,     /* pGetObjectW */
  45     NULL,                 /* pUnrealizeObject */
  46     BITMAP_DeleteObject   /* pDeleteObject */
  47 };
  48
  49
  50 /******************************************************************************
  51  *           NtGdiCreateCompatibleBitmap    (win32u.@)
  52  *
  53  * Creates a bitmap compatible with the DC.
  54  */
  55 HBITMAP WINAPI NtGdiCreateCompatibleBitmap( HDC hdc, INT width, INT height )
  56 {
  57     char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
  58     BITMAPINFO *bi = (BITMAPINFO *)buffer;
  59     DIBSECTION dib;
  60
  61     TRACE( "(%p,%d,%d)\n", hdc, width, height );
  62
  63     if (!width || !height) return 0;
  64
  65     if (get_gdi_object_type( hdc ) != NTGDI_OBJ_MEMDC)
  66         return NtGdiCreateBitmap( width, height,
  67                                   NtGdiGetDeviceCaps( hdc, PLANES ),
  68                                   NtGdiGetDeviceCaps( hdc, BITSPIXEL ), NULL );
  69
  70     switch (NtGdiExtGetObjectW( NtGdiGetDCObject( hdc, NTGDI_OBJ_SURF ),
  71                                 sizeof(dib), &dib ))
  72     {
  73     case sizeof(BITMAP): /* A device-dependent bitmap is selected in the DC */
  74         return NtGdiCreateBitmap( width, height, dib.dsBm.bmPlanes, dib.dsBm.bmBitsPixel, NULL );
  75
  76     case sizeof(DIBSECTION): /* A DIB section is selected in the DC */
  77         bi->bmiHeader = dib.dsBmih;
  78         bi->bmiHeader.biWidth  = width;
  79         bi->bmiHeader.biHeight = height;
  80         if (dib.dsBmih.biCompression == BI_BITFIELDS)  /* copy the color masks */
  81             memcpy( bi->bmiColors, dib.dsBitfields, sizeof(dib.dsBitfields) );
  82         else if (dib.dsBmih.biBitCount <= 8)  /* copy the color table */
  83             NtGdiDoPalette( hdc, 0, 256, bi->bmiColors, NtGdiGetDIBColorTable, FALSE );
  84         return NtGdiCreateDIBSection( hdc, NULL, 0, bi, DIB_RGB_COLORS, 0, 0, 0, NULL );
  85
  86     default:
  87         return 0;
  88     }
  89 }
  90
  91
  92 /******************************************************************************
  93  *      NtGdiCreateBitmap (win32u.@)
  94  *
  95  * Creates a bitmap with the specified info.
  96  */
  97 HBITMAP WINAPI NtGdiCreateBitmap( INT width, INT height, UINT planes,
  98                                   UINT bpp, const void *bits )
  99 {
 100     BITMAPOBJ *bmpobj;
 101     HBITMAP hbitmap;
 102     INT dib_stride;
 103     SIZE_T size;
 104
 105     if (width > 0x7ffffff || height > 0x7ffffff)
 106     {
 107         RtlSetLastWin32Error( ERROR_INVALID_PARAMETER );
 108         return 0;
 109     }
 110
 111     if (!width || !height)
 112         return 0;
 113
 114     if (height < 0)
 115         height = -height;
 116     if (width < 0)
 117         width = -width;
 118
 119     if (planes != 1)
 120     {
 121         FIXME("planes = %d\n", planes);
 122         RtlSetLastWin32Error( ERROR_INVALID_PARAMETER );
 123         return NULL;
 124     }
 125
 126     /* Windows only uses 1, 4, 8, 16, 24 and 32 bpp */
 127     if(bpp == 1)         bpp = 1;
 128     else if(bpp <= 4)    bpp = 4;
 129     else if(bpp <= 8)    bpp = 8;
 130     else if(bpp <= 16)   bpp = 16;
 131     else if(bpp <= 24)   bpp = 24;
 132     else if(bpp <= 32)   bpp = 32;
 133     else
 134     {
 135         WARN("Invalid bmBitsPixel %d, returning ERROR_INVALID_PARAMETER\n", bpp);
 136         RtlSetLastWin32Error(ERROR_INVALID_PARAMETER);
 137         return NULL;
 138     }
 139
 140     dib_stride = get_dib_stride( width, bpp );
 141     size = dib_stride * height;
 142     /* Check for overflow (dib_stride itself must be ok because of the constraint on bm.bmWidth above). */
 143     if (dib_stride != size / height)
 144     {
 145         RtlSetLastWin32Error( ERROR_INVALID_PARAMETER );
 146         return 0;
 147     }
 148
 149     /* Create the BITMAPOBJ */
 150     if (!(bmpobj = calloc( 1, sizeof(*bmpobj) )))
 151     {
 152         RtlSetLastWin32Error( ERROR_NOT_ENOUGH_MEMORY );
 153         return 0;
 154     }
 155
 156     bmpobj->dib.dsBm.bmType       = 0;
 157     bmpobj->dib.dsBm.bmWidth      = width;
 158     bmpobj->dib.dsBm.bmHeight     = height;
 159     bmpobj->dib.dsBm.bmWidthBytes = get_bitmap_stride( width, bpp );
 160     bmpobj->dib.dsBm.bmPlanes     = planes;
 161     bmpobj->dib.dsBm.bmBitsPixel  = bpp;
 162     bmpobj->dib.dsBm.bmBits       = calloc( 1, size );
 163     if (!bmpobj->dib.dsBm.bmBits)
 164     {
 165         free( bmpobj );
 166         RtlSetLastWin32Error( ERROR_NOT_ENOUGH_MEMORY );
 167         return 0;
 168     }
 169
 170     if (!(hbitmap = alloc_gdi_handle( &bmpobj->obj, NTGDI_OBJ_BITMAP, &bitmap_funcs )))
 171     {
 172         free( bmpobj->dib.dsBm.bmBits );
 173         free( bmpobj );
 174         return 0;
 175     }
 176
 177     if (bits)
 178         NtGdiSetBitmapBits( hbitmap, height * bmpobj->dib.dsBm.bmWidthBytes, bits );
 179
 180     TRACE("%dx%d, bpp %d planes %d: returning %p\n", width, height, bpp, planes, hbitmap);
 181     return hbitmap;
 182 }
 183
 184
 185 /***********************************************************************
 186  *      NtGdiGetBitmapBits (win32u.@)
 187  *
 188  * Copies bitmap bits of bitmap to buffer.
 189  *
 190  * RETURNS
 191  *    Success: Number of bytes copied
 192  *    Failure: 0
 193  */
 194 LONG WINAPI NtGdiGetBitmapBits(
 195     HBITMAP hbitmap, /* [in]  Handle to bitmap */
 196     LONG count,        /* [in]  Number of bytes to copy */
 197     LPVOID bits)       /* [out] Pointer to buffer to receive bits */
 198 {
 199     char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
 200     BITMAPINFO *info = (BITMAPINFO *)buffer;
 201     struct gdi_image_bits src_bits;
 202     struct bitblt_coords src;
 203     int dst_stride, max, ret;
 204     BITMAPOBJ *bmp = GDI_GetObjPtr( hbitmap, NTGDI_OBJ_BITMAP );
 205
 206     if (!bmp) return 0;
 207
 208     dst_stride = get_bitmap_stride( bmp->dib.dsBm.bmWidth, bmp->dib.dsBm.bmBitsPixel );
 209     ret = max = dst_stride * bmp->dib.dsBm.bmHeight;
 210     if (!bits) goto done;
 211     if (count < 0 || count > max) count = max;
 212     ret = count;
 213
 214     src.visrect.left = 0;
 215     src.visrect.right = bmp->dib.dsBm.bmWidth;
 216     src.visrect.top = 0;
 217     src.visrect.bottom = (count + dst_stride - 1) / dst_stride;
 218     src.x = src.y = 0;
 219     src.width = src.visrect.right - src.visrect.left;
 220     src.height = src.visrect.bottom - src.visrect.top;
 221
 222     if (!get_image_from_bitmap( bmp, info, &src_bits, &src ))
 223     {
 224         const char *src_ptr = src_bits.ptr;
 225         int src_stride = info->bmiHeader.biSizeImage / abs( info->bmiHeader.biHeight );
 226
 227         /* GetBitmapBits returns 16-bit aligned data */
 228
 229         if (info->bmiHeader.biHeight > 0)
 230         {
 231             src_ptr += (info->bmiHeader.biHeight - 1) * src_stride;
 232             src_stride = -src_stride;
 233         }
 234         src_ptr += src.visrect.top * src_stride;
 235
 236         if (src_stride == dst_stride) memcpy( bits, src_ptr, count );
 237         else while (count > 0)
 238         {
 239             memcpy( bits, src_ptr, min( count, dst_stride ) );
 240             src_ptr += src_stride;
 241             bits = (char *)bits + dst_stride;
 242             count -= dst_stride;
 243         }
 244         if (src_bits.free) src_bits.free( &src_bits );
 245     }
 246     else ret = 0;
 247
 248 done:
 249     GDI_ReleaseObj( hbitmap );
 250     return ret;
 251 }
 252
 253
 254 /******************************************************************************
 255  *      NtGdiSetBitmapBits (win32u.@)
 256  *
 257  * Sets bits of color data for a bitmap.
 258  *
 259  * RETURNS
 260  *    Success: Number of bytes used in setting the bitmap bits
 261  *    Failure: 0
 262  */
 263 LONG WINAPI NtGdiSetBitmapBits(
 264     HBITMAP hbitmap, /* [in] Handle to bitmap */
 265     LONG count,        /* [in] Number of bytes in bitmap array */
 266     LPCVOID bits)      /* [in] Address of array with bitmap bits */
 267 {
 268     char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
 269     BITMAPINFO *info = (BITMAPINFO *)buffer;
 270     BITMAPOBJ *bmp;
 271     DWORD err;
 272     int i, src_stride, dst_stride;
 273     struct bitblt_coords src, dst;
 274     struct gdi_image_bits src_bits;
 275     HRGN clip = NULL;
 276
 277     if (!bits) return 0;
 278
 279     bmp = GDI_GetObjPtr( hbitmap, NTGDI_OBJ_BITMAP );
 280     if (!bmp) return 0;
 281
 282     if (count < 0) {
 283         WARN("(%d): Negative number of bytes passed???\n", (int)count );
 284         count = -count;
 285     }
 286
 287     src_stride = get_bitmap_stride( bmp->dib.dsBm.bmWidth, bmp->dib.dsBm.bmBitsPixel );
 288     count = min( count, src_stride * bmp->dib.dsBm.bmHeight );
 289
 290     dst_stride = get_dib_stride( bmp->dib.dsBm.bmWidth, bmp->dib.dsBm.bmBitsPixel );
 291
 292     src.visrect.left   = src.x = 0;
 293     src.visrect.top    = src.y = 0;
 294     src.visrect.right  = src.width = bmp->dib.dsBm.bmWidth;
 295     src.visrect.bottom = src.height = (count + src_stride - 1 ) / src_stride;
 296     dst = src;
 297
 298     if (count % src_stride)
 299     {
 300         HRGN last_row;
 301         int extra_pixels = ((count % src_stride) << 3) / bmp->dib.dsBm.bmBitsPixel;
 302
 303         if ((count % src_stride << 3) % bmp->dib.dsBm.bmBitsPixel)
 304             FIXME( "Unhandled partial pixel\n" );
 305         clip = NtGdiCreateRectRgn( src.visrect.left, src.visrect.top,
 306                                    src.visrect.right, src.visrect.bottom - 1 );
 307         last_row = NtGdiCreateRectRgn( src.visrect.left, src.visrect.bottom - 1,
 308                                        src.visrect.left + extra_pixels, src.visrect.bottom );
 309         NtGdiCombineRgn( clip, clip, last_row, RGN_OR );
 310         NtGdiDeleteObjectApp( last_row );
 311     }
 312
 313     TRACE("(%p, %d, %p) %dx%d %d bpp fetched height: %d\n",
 314           hbitmap, (int)count, bits, bmp->dib.dsBm.bmWidth, bmp->dib.dsBm.bmHeight,
 315           bmp->dib.dsBm.bmBitsPixel, src.height );
 316
 317     if (src_stride == dst_stride)
 318     {
 319         src_bits.ptr = (void *)bits;
 320         src_bits.is_copy = FALSE;
 321         src_bits.free = NULL;
 322     }
 323     else
 324     {
 325         if (!(src_bits.ptr = malloc( dst.height * dst_stride )))
 326         {
 327             GDI_ReleaseObj( hbitmap );
 328             return 0;
 329         }
 330         src_bits.is_copy = TRUE;
 331         src_bits.free = free_heap_bits;
 332         for (i = 0; i < count / src_stride; i++)
 333             memcpy( (char *)src_bits.ptr + i * dst_stride, (char *)bits + i * src_stride, src_stride );
 334         if (count % src_stride)
 335             memcpy( (char *)src_bits.ptr + i * dst_stride, (char *)bits + i * src_stride, count % src_stride );
 336     }
 337
 338     /* query the color info */
 339     info->bmiHeader.biSize          = sizeof(info->bmiHeader);
 340     info->bmiHeader.biPlanes        = 1;
 341     info->bmiHeader.biBitCount      = bmp->dib.dsBm.bmBitsPixel;
 342     info->bmiHeader.biCompression   = BI_RGB;
 343     info->bmiHeader.biXPelsPerMeter = 0;
 344     info->bmiHeader.biYPelsPerMeter = 0;
 345     info->bmiHeader.biClrUsed       = 0;
 346     info->bmiHeader.biClrImportant  = 0;
 347     info->bmiHeader.biWidth         = 0;
 348     info->bmiHeader.biHeight        = 0;
 349     info->bmiHeader.biSizeImage     = 0;
 350     err = put_image_into_bitmap( bmp, 0, info, NULL, NULL, NULL );
 351
 352     if (!err || err == ERROR_BAD_FORMAT)
 353     {
 354         info->bmiHeader.biWidth     = bmp->dib.dsBm.bmWidth;
 355         info->bmiHeader.biHeight    = -dst.height;
 356         info->bmiHeader.biSizeImage = dst.height * dst_stride;
 357         err = put_image_into_bitmap( bmp, clip, info, &src_bits, &src, &dst );
 358     }
 359     if (err) count = 0;
 360
 361     if (clip) NtGdiDeleteObjectApp( clip );
 362     if (src_bits.free) src_bits.free( &src_bits );
 363     GDI_ReleaseObj( hbitmap );
 364     return count;
 365 }
 366
 367
 368 /***********************************************************************
 369  *           NtGdiSelectBitmap (win32u.@)
 370  */
 371 HGDIOBJ WINAPI NtGdiSelectBitmap( HDC hdc, HGDIOBJ handle )
 372 {
 373     HGDIOBJ ret;
 374     BITMAPOBJ *bitmap;
 375     DC *dc;
 376     PHYSDEV physdev;
 377
 378     if (!(dc = get_dc_ptr( hdc ))) return 0;
 379
 380     if (get_gdi_object_type( hdc ) != NTGDI_OBJ_MEMDC)
 381     {
 382         ret = 0;
 383         goto done;
 384     }
 385     ret = dc->hBitmap;
 386     if (handle == dc->hBitmap) goto done;  /* nothing to do */
 387
 388     if (!(bitmap = GDI_GetObjPtr( handle, NTGDI_OBJ_BITMAP )))
 389     {
 390         ret = 0;
 391         goto done;
 392     }
 393
 394     if (handle != GetStockObject( DEFAULT_BITMAP ) && GDI_get_ref_count( handle ))
 395     {
 396         WARN( "Bitmap already selected in another DC\n" );
 397         GDI_ReleaseObj( handle );
 398         ret = 0;
 399         goto done;
 400     }
 401
 402     if (!is_bitmapobj_dib( bitmap ) &&
 403         bitmap->dib.dsBm.bmBitsPixel != 1 &&
 404         bitmap->dib.dsBm.bmBitsPixel != NtGdiGetDeviceCaps( hdc, BITSPIXEL ) &&
 405         /* Display compatible DCs should accept 32-bit DDBs because other color depths are emulated */
 406         !(NtGdiGetDeviceCaps( hdc, TECHNOLOGY ) == DT_RASDISPLAY && bitmap->dib.dsBm.bmBitsPixel == 32))
 407     {
 408         WARN( "Wrong format bitmap %u bpp\n", bitmap->dib.dsBm.bmBitsPixel );
 409         GDI_ReleaseObj( handle );
 410         ret = 0;
 411         goto done;
 412     }
 413
 414     physdev = GET_DC_PHYSDEV( dc, pSelectBitmap );
 415     if (!physdev->funcs->pSelectBitmap( physdev, handle ))
 416     {
 417         GDI_ReleaseObj( handle );
 418         ret = 0;
 419     }
 420     else
 421     {
 422         dc->hBitmap = handle;
 423         GDI_inc_ref_count( handle );
 424         dc->dirty = 0;
 425         dc->attr->vis_rect.left   = 0;
 426         dc->attr->vis_rect.top    = 0;
 427         dc->attr->vis_rect.right  = bitmap->dib.dsBm.bmWidth;
 428         dc->attr->vis_rect.bottom = bitmap->dib.dsBm.bmHeight;
 429         dc->device_rect = dc->attr->vis_rect;
 430         GDI_ReleaseObj( handle );
 431         DC_InitDC( dc );
 432         GDI_dec_ref_count( ret );
 433     }
 434
 435  done:
 436     release_dc_ptr( dc );
 437     return ret;
 438 }
 439
 440
 441 /***********************************************************************
 442  *           BITMAP_DeleteObject
 443  */
 444 static BOOL BITMAP_DeleteObject( HGDIOBJ handle )
 445 {
 446     BITMAPOBJ *bmp = free_gdi_handle( handle );
 447
 448     if (!bmp) return FALSE;
 449     free( bmp->dib.dsBm.bmBits );
 450     free( bmp );
 451     return TRUE;
 452 }
 453
 454
 455 /***********************************************************************
 456  *           BITMAP_GetObject
 457  */
 458 static INT BITMAP_GetObject( HGDIOBJ handle, INT count, LPVOID buffer )
 459 {
 460     INT ret = 0;
 461     BITMAPOBJ *bmp = GDI_GetObjPtr( handle, NTGDI_OBJ_BITMAP );
 462
 463     if (!bmp) return 0;
 464
 465     if (!buffer) ret = sizeof(BITMAP);
 466     else if (count >= sizeof(BITMAP))
 467     {
 468         BITMAP *bitmap = buffer;
 469         *bitmap = bmp->dib.dsBm;
 470         bitmap->bmBits = NULL;
 471         ret = sizeof(BITMAP);
 472     }
 473     GDI_ReleaseObj( handle );
 474     return ret;
 475 }
 476
 477
 478 /******************************************************************************
 479  *      NtGdiGetBitmapDimension (win32u.@)
 480  *
 481  * Retrieves dimensions of a bitmap.
 482  *
 483  * RETURNS
 484  *    Success: TRUE
 485  *    Failure: FALSE
 486  */
 487 BOOL WINAPI NtGdiGetBitmapDimension(
 488     HBITMAP hbitmap, /* [in]  Handle to bitmap */
 489     LPSIZE size)     /* [out] Address of struct receiving dimensions */
 490 {
 491     BITMAPOBJ * bmp = GDI_GetObjPtr( hbitmap, NTGDI_OBJ_BITMAP );
 492     if (!bmp) return FALSE;
 493     *size = bmp->size;
 494     GDI_ReleaseObj( hbitmap );
 495     return TRUE;
 496 }
 497
 498
 499 /******************************************************************************
 500  *      NtGdiSetBitmapDimension (win32u.@)
 501  *
 502  * Assigns dimensions to a bitmap.
 503  * MSDN says that this function will fail if hbitmap is a handle created by
 504  * CreateDIBSection, but that's not true on Windows 2000.
 505  *
 506  * RETURNS
 507  *    Success: TRUE
 508  *    Failure: FALSE
 509  */
 510 BOOL WINAPI NtGdiSetBitmapDimension(
 511     HBITMAP hbitmap, /* [in]  Handle to bitmap */
 512     INT x,           /* [in]  Bitmap width */
 513     INT y,           /* [in]  Bitmap height */
 514     LPSIZE prevSize) /* [out] Address of structure for orig dims */
 515 {
 516     BITMAPOBJ * bmp = GDI_GetObjPtr( hbitmap, NTGDI_OBJ_BITMAP );
 517     if (!bmp) return FALSE;
 518     if (prevSize) *prevSize = bmp->size;
 519     bmp->size.cx = x;
 520     bmp->size.cy = y;
 521     GDI_ReleaseObj( hbitmap );
 522     return TRUE;
 523 }