bitmaps.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
INT APIENTRY	BITMAP_GetObject (SURFACE *bmp, INT count, LPVOID buffer)
HBITMAP FASTCALL	BITMAP_CopyBitmap (HBITMAP hBitmap)
BOOL NTAPI	GreSetBitmapOwner (_In_ HBITMAP hbmp, _In_ ULONG ulOwner)
HBITMAP NTAPI	GreCreateBitmap (_In_ ULONG nWidth, _In_ ULONG nHeight, _In_ ULONG cPlanes, _In_ ULONG cBitsPixel, _In_opt_ PVOID pvBits)
HBITMAP NTAPI	GreCreateBitmapEx (_In_ ULONG nWidth, _In_ ULONG nHeight, _In_ ULONG cjWidthBytes, _In_ ULONG iFormat, _In_ USHORT fjBitmap, _In_ ULONG cjSizeImage, _In_opt_ PVOID pvBits, _In_ FLONG flags)
HBITMAP NTAPI	GreCreateDIBitmapInternal (IN HDC hDc, IN INT cx, IN INT cy, IN DWORD fInit, IN OPTIONAL LPBYTE pjInit, IN OPTIONAL PBITMAPINFO pbmi, IN DWORD iUsage, IN FLONG fl, IN UINT cjMaxBits, IN HANDLE hcmXform)
BOOL NTAPI	GreGetBitmapDimension (_In_ HBITMAP hBitmap, _Out_ LPSIZE psizDim)

Function Documentation

BITMAP_CopyBitmap()

HBITMAP FASTCALL BITMAP_CopyBitmap

(

HBITMAP

hBitmap

)

Definition at line 714 of file bitmaps.c.

{
    HBITMAP hbmNew;
    SURFACE *psurfSrc, *psurfNew;
 
    /* Fail, if no source bitmap is given */
    if (hBitmap == NULL) return 0;
 
    /* Lock the source bitmap */
    psurfSrc = SURFACE_ShareLockSurface(hBitmap);
    if (psurfSrc == NULL)
    {
        return 0;
    }
 
    /* Allocate a new bitmap with the same dimensions as the source bmp */
    hbmNew = GreCreateBitmapEx(psurfSrc->SurfObj.sizlBitmap.cx,
                               psurfSrc->SurfObj.sizlBitmap.cy,
                               abs(psurfSrc->SurfObj.lDelta),
                               psurfSrc->SurfObj.iBitmapFormat,
                               psurfSrc->SurfObj.fjBitmap & BMF_TOPDOWN,
                               psurfSrc->SurfObj.cjBits,
                               NULL,
                               psurfSrc->flags);
 
    if (hbmNew)
    {
        /* Lock the new bitmap */
        psurfNew = SURFACE_ShareLockSurface(hbmNew);
        if (psurfNew)
        {
            /* Copy the bitmap bits to the new bitmap buffer */
            RtlCopyMemory(psurfNew->SurfObj.pvBits,
                          psurfSrc->SurfObj.pvBits,
                          psurfNew->SurfObj.cjBits);
 
 
            /* Reference the palette of the source bitmap and use it */
            SURFACE_vSetPalette(psurfNew, psurfSrc->ppal);
 
            /* Unlock the new surface */
            SURFACE_ShareUnlockSurface(psurfNew);
        }
        else
        {
            /* Failed to lock the bitmap, shouldn't happen */
            GreDeleteObject(hbmNew);
            hbmNew = NULL;
        }
    }
 
    /* Unlock the source bitmap and return the handle of the new bitmap */
    SURFACE_ShareUnlockSurface(psurfSrc);
    return hbmNew;
}

Referenced by _Success_(), and NtGdiCreatePatternBrushInternal().

BITMAP_GetObject()

INT APIENTRY BITMAP_GetObject	(	SURFACE *	bmp,
		INT	count,
		LPVOID	buffer
	)

Definition at line 771 of file bitmaps.c.

{
    PBITMAP pBitmap;
 
    if (!buffer) return sizeof(BITMAP);
    if ((UINT)Count < sizeof(BITMAP)) return 0;
 
    /* Always fill a basic BITMAP structure */
    pBitmap = buffer;
    pBitmap->bmType = 0;
    pBitmap->bmWidth = psurf->SurfObj.sizlBitmap.cx;
    pBitmap->bmHeight = psurf->SurfObj.sizlBitmap.cy;
    pBitmap->bmPlanes = 1;
    pBitmap->bmBitsPixel = BitsPerFormat(psurf->SurfObj.iBitmapFormat);
    pBitmap->bmWidthBytes = WIDTH_BYTES_ALIGN16(pBitmap->bmWidth, pBitmap->bmBitsPixel);
 
    /* Check for DIB section */
    if (psurf->hSecure)
    {
        /* Set bmBits in this case */
        pBitmap->bmBits = psurf->SurfObj.pvBits;
        /* DIBs data are 32 bits aligned */
        pBitmap->bmWidthBytes = WIDTH_BYTES_ALIGN32(pBitmap->bmWidth, pBitmap->bmBitsPixel);
 
        if (Count >= sizeof(DIBSECTION))
        {
            /* Fill rest of DIBSECTION */
            PDIBSECTION pds = buffer;
 
            pds->dsBmih.biSize = sizeof(BITMAPINFOHEADER);
            pds->dsBmih.biWidth = pds->dsBm.bmWidth;
            pds->dsBmih.biHeight = pds->dsBm.bmHeight;
            pds->dsBmih.biPlanes = pds->dsBm.bmPlanes;
            pds->dsBmih.biBitCount = pds->dsBm.bmBitsPixel;
 
            switch (psurf->SurfObj.iBitmapFormat)
            {
                case BMF_1BPP:
                case BMF_4BPP:
                case BMF_8BPP:
                   pds->dsBmih.biCompression = BI_RGB;
                   break;
 
                case BMF_16BPP:
                    if (psurf->ppal->flFlags & PAL_RGB16_555)
                        pds->dsBmih.biCompression = BI_RGB;
                    else
                        pds->dsBmih.biCompression = BI_BITFIELDS;
                    break;
 
                case BMF_24BPP:
                case BMF_32BPP:
                    /* 24/32bpp BI_RGB is actually BGR format */
                    if (psurf->ppal->flFlags & PAL_BGR)
                        pds->dsBmih.biCompression = BI_RGB;
                    else
                        pds->dsBmih.biCompression = BI_BITFIELDS;
                    break;
 
                case BMF_4RLE:
                   pds->dsBmih.biCompression = BI_RLE4;
                   break;
                case BMF_8RLE:
                   pds->dsBmih.biCompression = BI_RLE8;
                   break;
                case BMF_JPEG:
                   pds->dsBmih.biCompression = BI_JPEG;
                   break;
                case BMF_PNG:
                   pds->dsBmih.biCompression = BI_PNG;
                   break;
                default:
                    ASSERT(FALSE); /* This shouldn't happen */
            }
 
            pds->dsBmih.biSizeImage = psurf->SurfObj.cjBits;
            pds->dsBmih.biXPelsPerMeter = 0;
            pds->dsBmih.biYPelsPerMeter = 0;
            pds->dsBmih.biClrUsed = psurf->ppal->NumColors;
            pds->dsBmih.biClrImportant = psurf->biClrImportant;
            pds->dsBitfields[0] = psurf->ppal->RedMask;
            pds->dsBitfields[1] = psurf->ppal->GreenMask;
            pds->dsBitfields[2] = psurf->ppal->BlueMask;
            pds->dshSection = psurf->hDIBSection;
            pds->dsOffset = psurf->dwOffset;
 
            return sizeof(DIBSECTION);
        }
    }
    else
    {
        /* Not set according to wine test, confirmed in win2k */
        pBitmap->bmBits = NULL;
    }
 
    return sizeof(BITMAP);
}

Referenced by GreGetObject(), and IntCreateCompatibleBitmap().

GreCreateBitmap()

HBITMAP NTAPI GreCreateBitmap	(	_In_ ULONG	nWidth,
		_In_ ULONG	nHeight,
		_In_ ULONG	cPlanes,
		_In_ ULONG	cBitsPixel,
		_In_opt_ PVOID	pvBits
	)

Definition at line 172 of file bitmaps.c.

{
    /* Call the extended function */
    return GreCreateBitmapEx(nWidth,
                             nHeight,
                             0, /* Auto width */
                             BitmapFormat(cBitsPixel * cPlanes, BI_RGB),
                             0, /* No bitmap flags */
                             0, /* Auto size */
                             pvBits,
                             DDB_SURFACE /* DDB */);
}

Referenced by CreateStockObjects(), IntCreateCompatibleBitmap(), IntCreateDIBitmap(), NtGdiCreateCompatibleBitmap(), and UserInitialize().

GreCreateBitmapEx()

HBITMAP NTAPI GreCreateBitmapEx	(	_In_ ULONG	nWidth,
		_In_ ULONG	nHeight,
		_In_ ULONG	cjWidthBytes,
		_In_ ULONG	iFormat,
		_In_ USHORT	fjBitmap,
		_In_ ULONG	cjSizeImage,
		_In_opt_ PVOID	pvBits,
		_In_ FLONG	flags
	)

Definition at line 101 of file bitmaps.c.

{
    PSURFACE psurf;
    HBITMAP hbmp;
    PVOID pvCompressedBits = NULL;
 
    /* Verify format */
    if (iFormat < BMF_1BPP || iFormat > BMF_PNG) return NULL;
 
    /* The infamous RLE hack */
    if ((iFormat == BMF_4RLE) || (iFormat == BMF_8RLE))
    {
        pvCompressedBits = pvBits;
        pvBits = NULL;
        iFormat = (iFormat == BMF_4RLE) ? BMF_4BPP : BMF_8BPP;
    }
 
    /* Allocate a surface */
    psurf = SURFACE_AllocSurface(STYPE_BITMAP,
                                 nWidth,
                                 nHeight,
                                 iFormat,
                                 fjBitmap,
                                 cjWidthBytes,
                                 pvCompressedBits ? 0 : cjSizeImage,
                                 pvBits);
    if (!psurf)
    {
        DPRINT1("SURFACE_AllocSurface failed.\n");
        return NULL;
    }
 
    /* The infamous RLE hack */
    if (pvCompressedBits)
    {
        SIZEL sizl;
        LONG lDelta;
 
        sizl.cx = nWidth;
        sizl.cy = nHeight;
        lDelta = WIDTH_BYTES_ALIGN32(nWidth, gajBitsPerFormat[iFormat]);
 
        pvBits = psurf->SurfObj.pvBits;
        DecompressBitmap(sizl, pvCompressedBits, pvBits, lDelta, iFormat, cjSizeImage);
    }
 
    /* Get the handle for the bitmap */
    hbmp = (HBITMAP)psurf->SurfObj.hsurf;
 
    /* Mark as API bitmap */
    psurf->flags |= (flags | API_BITMAP);
 
    /* Unlock the surface and return */
    SURFACE_UnlockSurface(psurf);
    return hbmp;
}

Referenced by BITMAP_CopyBitmap(), DIB_CreateDIBSection(), GreCreateBitmap(), IntGdiCreateMaskFromRLE(), IntSetDIBits(), NtGdiSetDIBitsToDeviceInternal(), and NtGdiStretchDIBitsInternal().

GreCreateDIBitmapInternal()

HBITMAP NTAPI GreCreateDIBitmapInternal	(	IN HDC	hDc,
		IN INT	cx,
		IN INT	cy,
		IN DWORD	fInit,
		IN OPTIONAL LPBYTE	pjInit,
		IN OPTIONAL PBITMAPINFO	pbmi,
		IN DWORD	iUsage,
		IN FLONG	fl,
		IN UINT	cjMaxBits,
		IN HANDLE	hcmXform
	)

Definition at line 1718 of file dibobj.c.

{
    PDC Dc;
    HBITMAP Bmp;
    USHORT bpp, planes;
    DWORD compression;
    HDC hdcDest;
 
    if (!hDc) /* 1bpp monochrome bitmap */
    {
        // Should use System Bitmap DC hSystemBM, with CreateCompatibleDC for this.
        hdcDest = NtGdiCreateCompatibleDC(0);
        if(!hdcDest)
        {
            DPRINT1("NtGdiCreateCompatibleDC failed\n");
            return NULL;
        }
    }
    else
    {
        hdcDest = hDc;
    }
 
    Dc = DC_LockDc(hdcDest);
    if (!Dc)
    {
        DPRINT1("Failed to lock hdcDest %p\n", hdcDest);
        EngSetLastError(ERROR_INVALID_HANDLE);
        return NULL;
    }
    /* It's OK to set bpp=0 here, as IntCreateDIBitmap will create a compatible Bitmap
     * if bpp != 1 and ignore the real value that was passed */
    if (pbmi)
    {
        if (pbmi->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
        {
            BITMAPCOREHEADER* CoreHeader = (BITMAPCOREHEADER*)&pbmi->bmiHeader;
            bpp = CoreHeader->bcBitCount;
            planes = CoreHeader->bcPlanes ? CoreHeader->bcPlanes : 1;
            compression = BI_RGB;
        }
        else
        {
            bpp = pbmi->bmiHeader.biBitCount;
            planes = pbmi->bmiHeader.biPlanes ? pbmi->bmiHeader.biPlanes : 1;
            compression = pbmi->bmiHeader.biCompression;
        }
    }
    else
    {
        bpp = 0;
        planes = 0;
        compression = 0;
    }
    Bmp = IntCreateDIBitmap(Dc, cx, cy, planes, bpp, compression, fInit, pjInit, cjMaxBits, pbmi, iUsage);
    DC_UnlockDc(Dc);
 
    if(!hDc)
    {
        NtGdiDeleteObjectApp(hdcDest);
    }
    return Bmp;
}

Referenced by GreCreateDIBitmapFromPackedDIB(), IntSynthesizeBitmap(), NtGdiCreateDIBitmapInternal(), and UserLoadImage().

GreGetBitmapDimension()

BOOL NTAPI GreGetBitmapDimension	(	_In_ HBITMAP	hBitmap,
		_Out_ LPSIZE	psizDim
	)

Definition at line 453 of file bitmaps.c.

{
    PSURFACE psurfBmp;
 
    if (hBitmap == NULL)
        return FALSE;
 
    /* Lock the bitmap */
    psurfBmp = SURFACE_ShareLockSurface(hBitmap);
    if (psurfBmp == NULL)
    {
        EngSetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }
 
    *psizDim = psurfBmp->sizlDim;
 
    /* Unlock the bitmap */
    SURFACE_ShareUnlockSurface(psurfBmp);
 
    return TRUE;
}

Referenced by co_IntDrawCaret(), and NtGdiGetBitmapDimension().

GreSetBitmapOwner()

BOOL NTAPI GreSetBitmapOwner	(	_In_ HBITMAP	hbmp,
		_In_ ULONG	ulOwner
	)

FIXME: this is a hack and doesn't handle a race condition properly. It needs to be done in GDIOBJ_vSetObjectOwner atomically.

Definition at line 17 of file bitmaps.c.

{
    /* Check if we have the correct object type */
    if (GDI_HANDLE_GET_TYPE(hbmp) != GDILoObjType_LO_BITMAP_TYPE)
    {
        DPRINT1("Incorrect type for hbmp: %p\n", hbmp);
        return FALSE;
    }
 
 
    /* Check if we set public or none */
    if ((ulOwner == GDI_OBJ_HMGR_PUBLIC) ||
        (ulOwner == GDI_OBJ_HMGR_NONE))
    {
        /* Only allow this for owned objects */
        if (GreGetObjectOwner(hbmp) != GDI_OBJ_HMGR_POWNED)
        {
            DPRINT1("Cannot change owner for non-powned hbmp\n");
            return FALSE;
        }
    }
 
    return GreSetObjectOwner(hbmp, ulOwner);
}

Referenced by CreateBrushInternal(), DxEngSetBitmapOwner(), IntGdiCreatePatternBrush(), IntSetCursorData(), and BRUSH::~BRUSH().