bitmap.c File Reference

#include <precomp.h>
#include <debug.h>

Include dependency graph for bitmap.c:

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

Go to the source code of this file.

Macros
#define	NDEBUG
#define	WIDTH_BYTES_ALIGN32(cx, bpp)   ((((cx) * (bpp) + 31) & ~31) >> 3)

Functions
INT FASTCALL	DIB_BitmapInfoSize (const BITMAPINFO *info, WORD coloruse, BOOL max)
UINT FASTCALL	DIB_BitmapMaxBitsSize (PBITMAPINFO Info, UINT ScanLines)
INT WINAPI	DIB_GetBitmapInfo (const BITMAPINFOHEADER *header, PLONG width, PLONG height, PWORD planes, PWORD bpp, PLONG compr, PLONG size)
int WINAPI	GdiGetBitmapBitsSize (BITMAPINFO *lpbmi)
HBITMAP WINAPI	CreateDIBSection (HDC hDC, CONST BITMAPINFO *BitmapInfo, UINT Usage, VOID **Bits, HANDLE hSection, DWORD dwOffset)
HBITMAP WINAPI	CreateBitmap (INT Width, INT Height, UINT Planes, UINT BitsPixel, CONST VOID *pUnsafeBits)
HBITMAP WINAPI	CreateBitmapIndirect (const BITMAP *pbm)
HBITMAP WINAPI	CreateDiscardableBitmap (HDC hDC, INT Width, INT Height)
HBITMAP WINAPI	CreateCompatibleBitmap (HDC hDC, INT Width, INT Height)
INT WINAPI	GetDIBits (HDC hDC, HBITMAP hbmp, UINT uStartScan, UINT cScanLines, LPVOID lpvBits, LPBITMAPINFO lpbmi, UINT uUsage)
HBITMAP WINAPI	CreateDIBitmap (HDC hDC, const BITMAPINFOHEADER *Header, DWORD Init, LPCVOID Bits, const BITMAPINFO *Data, UINT ColorUse)
INT WINAPI	SetDIBits (HDC hDC, HBITMAP hBitmap, UINT uStartScan, UINT cScanLines, CONST VOID *lpvBits, CONST BITMAPINFO *lpbmi, UINT fuColorUse)
INT WINAPI	SetDIBitsToDevice (HDC hdc, int XDest, int YDest, DWORD Width, DWORD Height, int XSrc, int YSrc, UINT StartScan, UINT ScanLines, CONST VOID *Bits, CONST BITMAPINFO *lpbmi, UINT ColorUse)
int WINAPI	StretchDIBits (HDC hdc, int XDest, int YDest, int nDestWidth, int nDestHeight, int XSrc, int YSrc, int nSrcWidth, int nSrcHeight, CONST VOID *lpBits, CONST BITMAPINFO *lpBitsInfo, UINT iUsage, DWORD dwRop)
DWORD WINAPI	GetBitmapAttributes (HBITMAP hbm)
HBITMAP WINAPI	SetBitmapAttributes (HBITMAP hbm, DWORD dwFlags)
HBITMAP WINAPI	ClearBitmapAttributes (HBITMAP hbm, DWORD dwFlags)
HBITMAP WINAPI	GdiConvertBitmapV5 (HBITMAP in_format_BitMap, HBITMAP src_BitMap, INT bpp, INT unuse)

Macro Definition Documentation

#define NDEBUG

Definition at line 3 of file bitmap.c.

#define WIDTH_BYTES_ALIGN32	(		cx,
			bpp
	)		((((cx) * (bpp) + 31) & ~31) >> 3)

Definition at line 7 of file bitmap.c.

Referenced by DIB_BitmapMaxBitsSize(), and GdiGetBitmapBitsSize().

Function Documentation

HBITMAP WINAPI ClearBitmapAttributes	(	HBITMAP	hbm,
		DWORD	dwFlags
	)

Definition at line 918 of file bitmap.c.

{
    UNIMPLEMENTED;
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
}

HBITMAP WINAPI CreateBitmap	(	INT	Width,
		INT	Height,
		UINT	Planes,
		UINT	BitsPixel,
		CONST VOID *	pUnsafeBits
	)

Definition at line 252 of file bitmap.c.

Referenced by CreateBitmapIndirect(), test_32bit_ddb(), test_bitmap(), test_bitmap_colors(), test_bmBits(), test_CreateBitmap(), test_CreateBitmapFromHICON(), test_GdiAlphaBlend(), test_get16dibits(), test_GetDIBits(), test_GetDIBits_selected_DDB(), test_mono_bitmap(), test_select_object(), and test_StretchBlt().

{
    if (Width && Height)
    {
        return NtGdiCreateBitmap(Width, Height, Planes, BitsPixel, (LPBYTE) pUnsafeBits);
    }
    else
    {
        /* Return 1x1 bitmap */
        return GetStockObject(DEFAULT_BITMAP);
    }
}

HBITMAP WINAPI CreateBitmapIndirect

(

const BITMAP *

pbm

)

Definition at line 275 of file bitmap.c.

Referenced by test_CreateBitmap().

{
    HBITMAP bitmap = NULL;

    /* Note windows xp/2003 does not check if pbm is NULL or not */
    if ((pbm->bmWidthBytes != 0) && (!(pbm->bmWidthBytes & 1)))

    {
        bitmap = CreateBitmap(pbm->bmWidth, pbm->bmHeight, pbm->bmPlanes, pbm->bmBitsPixel,
            pbm->bmBits);
    }
    else
    {
        SetLastError(ERROR_INVALID_PARAMETER);
    }

    return bitmap;
}

HBITMAP WINAPI CreateCompatibleBitmap	(	HDC	hDC,
		INT	Width,
		INT	Height
	)

Definition at line 307 of file bitmap.c.

Referenced by CreateDiscardableBitmap(), test_CreateBitmap(), test_createdibitmap(), test_D3DKMTCreateDCFromMemory(), test_dib_formats(), test_GdiAlphaBlend(), test_GetDIBits(), test_GetDIBits_BI_BITFIELDS(), test_GetDIBits_selected_DDB(), test_GetSetDIBits_rtl(), and test_select_object().

{
    PDC_ATTR pDc_Attr;

    if (!GdiGetHandleUserData(hDC, GDI_OBJECT_TYPE_DC, (PVOID) & pDc_Attr))
        return NULL;

    if (!Width || !Height)
        return GetStockObject(DEFAULT_BITMAP);

    if (!(pDc_Attr->ulDirty_ & DC_DIBSECTION))
    {
        return NtGdiCreateCompatibleBitmap(hDC, Width, Height);
    }
    else
    {
        HBITMAP hBmp = NULL;
        struct
        {
            BITMAP bitmap;
            BITMAPINFOHEADER bmih;
            RGBQUAD rgbquad[256];
        } buffer;
        DIBSECTION* pDIBs = (DIBSECTION*) &buffer;
        BITMAPINFO* pbmi = (BITMAPINFO*) &buffer.bmih;

        hBmp = NtGdiGetDCObject(hDC, GDI_OBJECT_TYPE_BITMAP);

        if (GetObjectA(hBmp, sizeof(DIBSECTION), pDIBs) != sizeof(DIBSECTION))
            return NULL;

        if (pDIBs->dsBm.bmBitsPixel <= 8)
            GetDIBColorTable(hDC, 0, 256, buffer.rgbquad);

        pDIBs->dsBmih.biWidth = Width;
        pDIBs->dsBmih.biHeight = Height;

        return CreateDIBSection(hDC, pbmi, DIB_RGB_COLORS, NULL, NULL, 0);
    }
    return NULL;
}

HBITMAP WINAPI CreateDIBitmap	(	HDC	hDC,
		const BITMAPINFOHEADER *	Header,
		DWORD	Init,
		LPCVOID	Bits,
		const BITMAPINFO *	Data,
		UINT	ColorUse
	)

Definition at line 398 of file bitmap.c.

Referenced by test_createdibitmap(), and test_dib_formats().

{
    LONG Width, Height, Compression, DibSize;
    WORD Planes, BitsPerPixel;
//  PDC_ATTR pDc_Attr;
    UINT cjBmpScanSize = 0;
    HBITMAP hBitmap = NULL;
    PBITMAPINFO pbmiConverted;
    UINT cjInfoSize;

    /* Convert the BITMAPINFO if it is a COREINFO */
    pbmiConverted = ConvertBitmapInfo(Data, ColorUse, &cjInfoSize, FALSE);

    /* Check for CBM_CREATDIB */
    if (Init & CBM_CREATDIB)
    {
        if (cjInfoSize == 0)
        {
            goto Exit;
        }
        else if (Init & CBM_INIT)
        {
            if (Bits == NULL)
            {
                goto Exit;
            }
        }
        else
        {
            Bits = NULL;
        }

        /* CBM_CREATDIB needs Data. */
        if (pbmiConverted == NULL)
        {
            DPRINT1("CBM_CREATDIB needs a BITMAPINFO!\n");
            goto Exit;
        }

        /* It only works with PAL or RGB */
        if (ColorUse > DIB_PAL_COLORS)
        {
            DPRINT1("Invalid ColorUse: %lu\n", ColorUse);
            GdiSetLastError(ERROR_INVALID_PARAMETER);
            goto Exit;
        }

        /* Use the header from the data */
        Header = &Data->bmiHeader;
    }
    else
    {
        if (Init & CBM_INIT)
        {
            if (Bits != NULL)
            {
                if (cjInfoSize == 0)
                {
                    goto Exit;
                }
            }
            else
            {
                Init &= ~CBM_INIT;
            }
        }
    }

    /* Header is required */
    if (!Header)
    {
        DPRINT1("Header is NULL\n");
        GdiSetLastError(ERROR_INVALID_PARAMETER);
        goto Exit;
    }

    /* Get the bitmap format and dimensions */
    if (DIB_GetBitmapInfo(Header, &Width, &Height, &Planes, &BitsPerPixel, &Compression, &DibSize) == -1)
    {
        DPRINT1("DIB_GetBitmapInfo failed!\n");
        GdiSetLastError(ERROR_INVALID_PARAMETER);
        goto Exit;
    }

    /* Check if the Compr is incompatible */
    if ((Compression == BI_JPEG) || (Compression == BI_PNG) || (Compression == BI_BITFIELDS))
    {
        DPRINT1("Invalid compression: %lu!\n", Compression);
        goto Exit;
    }

    /* Only DIB_RGB_COLORS (0), DIB_PAL_COLORS (1) and 2 are valid. */
    if (ColorUse > DIB_PAL_COLORS + 1)
    {
        DPRINT1("Invalid compression: %lu!\n", Compression);
        GdiSetLastError(ERROR_INVALID_PARAMETER);
        goto Exit;
    }

    /* If some Bits are given, only DIB_PAL_COLORS and DIB_RGB_COLORS are valid */
    if (Bits && (ColorUse > DIB_PAL_COLORS))
    {
        DPRINT1("Invalid ColorUse: %lu\n", ColorUse);
        GdiSetLastError(ERROR_INVALID_PARAMETER);
        goto Exit;
    }

    /* Negative width is not allowed */
    if (Width < 0)
    {
        DPRINT1("Negative width: %li\n", Width);
        goto Exit;
    }

    /* Top-down DIBs have a negative height. */
    Height = abs(Height);

// For Icm support.
// GdiGetHandleUserData(hdc, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr))

    cjBmpScanSize = GdiGetBitmapBitsSize(pbmiConverted);

    DPRINT("pBMI %p, Size bpp %u, dibsize %d, Conv %u, BSS %u\n",
           Data, BitsPerPixel, DibSize, cjInfoSize, cjBmpScanSize);

    if (!Width || !Height)
    {
        hBitmap = GetStockObject(DEFAULT_BITMAP);
    }
    else
    {
        hBitmap = NtGdiCreateDIBitmapInternal(hDC,
                                              Width,
                                              Height,
                                              Init,
                                              (LPBYTE)Bits,
                                              (LPBITMAPINFO)pbmiConverted,
                                              ColorUse,
                                              cjInfoSize,
                                              cjBmpScanSize,
                                              0, 0);
    }

Exit:
    /* Cleanup converted BITMAPINFO */
    if ((pbmiConverted != NULL) && (pbmiConverted != Data))
    {
        RtlFreeHeap(RtlGetProcessHeap(), 0, pbmiConverted);
    }

    return hBitmap;
}

HBITMAP WINAPI CreateDIBSection	(	HDC	hDC,
		CONST BITMAPINFO *	BitmapInfo,
		UINT	Usage,
		VOID **	Bits,
		HANDLE	hSection,
		DWORD	dwOffset
	)

Definition at line 197 of file bitmap.c.

Referenced by alpha_blend_hdc_pixels(), alpha_blend_image(), ARGB2BMP(), BITMAP_CopyImage(), BITMAP_LoadImageW(), ConvertBitmapTo32Bpp(), Create24BppBitmap(), Create32BitHBITMAP(), create_bitmap(), create_dib(), create_hatch_bitmap(), create_render_dc(), create_test_bitmap(), create_test_icon(), CreateCompatibleBitmap(), CreateDIBWithProperties(), ATL::CImage::CreateInternal(), CreateStarBitmap(), draw_graphics(), DrawDibBegin(), DrawShadowText(), GdipCreateBitmapFromScan0(), GdipCreateHBITMAPFromBitmap(), GdipDrawImagePointsRect(), GdipGetDC(), ID3DXFontImpl_DrawTextW(), ImageList_CreateImage(), InitBitmap(), InitLogo(), InitPerBitDepth(), LoadDIBImage(), mi_paint_rect(), mstsc_ProtocolIOThread(), OLEPictureImpl_LoadWICSource(), PaintCells(), PlayEnhMetaFileRecord(), START_TEST(), sw_fb_renderbuffer_storage(), test_32bit_ddb(), test_alpha_hdc(), test_BitBlt(), test_bitmap_colors(), test_bitmap_font_glyph_index(), test_bitmap_rendering(), test_bitmapinfoheadersize(), test_boundsrect(), test_clipping(), test_color_table(), test_CopyImage_Bitmap(), test_CreateIcon(), test_data_handles(), test_device_caps(), test_dib_formats(), test_DIB_PAL_COLORS(), Test_Dibsection(), test_dibsections(), test_DrawDib_sizeimage(), test_DrawIcon(), test_DrawIconEx(), test_DrawState(), test_emf_BitBlt(), test_GdiAlphaBlend(), test_GdiGradientFill(), test_GdipCreateBitmapFromHBITMAP(), test_GetCursorFrameInfo(), Test_GetDIBColorTable(), test_GetDIBits_BI_BITFIELDS(), test_GetDIBits_scanlines(), test_GetDIBits_selected_DIB(), test_GetDIBits_top_down(), test_hdc_caching(), test_ImageList_DrawIndirect(), Test_MaskBlt_16bpp(), Test_MaskBlt_1bpp(), Test_MaskBlt_32bpp(), Test_MaskBlt_Brush(), test_mono_dibsection(), Test_NtGdiDoPalette_SetDIBColorTable(), test_palette_brush(), test_path_state(), test_pattern_brush(), Test_SelectDIBSection(), Test_SetDIBits(), test_SetDIBits(), test_SetDIBits_RLE4(), test_SetDIBits_RLE8(), test_SetDIBitsToDevice(), test_SetDIBitsToDevice_RLE8(), Test_SetPixel_PAL(), test_simple_graphics(), Test_SrcMono(), test_StretchBlt(), test_StretchDIBits(), UXTHEME_DrawThemePartToDib(), and WinGCreateBitmap().

{
    PBITMAPINFO pConvertedInfo;
    UINT ConvertedInfoSize;
    HBITMAP hBitmap = NULL;
    PVOID bmBits = NULL;

    pConvertedInfo = ConvertBitmapInfo(BitmapInfo, Usage, &ConvertedInfoSize,
    FALSE);

    if (pConvertedInfo)
    {
        // Verify header due to converted may == info.
        if (pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER))
        {
            if (pConvertedInfo->bmiHeader.biCompression == BI_JPEG
                || pConvertedInfo->bmiHeader.biCompression == BI_PNG)
            {
                SetLastError(ERROR_INVALID_PARAMETER);
                return NULL;
            }
        }
        bmBits = Bits;
        hBitmap = NtGdiCreateDIBSection(hDC, hSection, dwOffset, pConvertedInfo, Usage,
            ConvertedInfoSize, 0, // fl
            0, // dwColorSpace
            &bmBits);

        if (BitmapInfo != pConvertedInfo)
            RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);

        if (!hBitmap)
        {
            bmBits = NULL;
        }
    }

    if (Bits)
        *Bits = bmBits;

    return hBitmap;
}

HBITMAP WINAPI CreateDiscardableBitmap	(	HDC	hDC,
		INT	Width,
		INT	Height
	)

Definition at line 297 of file bitmap.c.

Referenced by test_CreateBitmap().

{
    return CreateCompatibleBitmap(hDC, Width, Height);
}

INT FASTCALL DIB_BitmapInfoSize	(	const BITMAPINFO *	info,
		WORD	coloruse,
		BOOL	max
	)

Definition at line 17 of file bitmap.c.

Referenced by GetDIBits(), IntSynthesizeBitmap(), and IntSynthesizeDib().

{
    unsigned int colors, size, masks = 0;

    if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
    {
        const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *) info;
        size = sizeof(BITMAPCOREHEADER);
        if (core->bcBitCount <= 8)
        {
            colors = 1 << core->bcBitCount;
            if (coloruse == DIB_RGB_COLORS)
                size += colors * sizeof(RGBTRIPLE);
            else
                size += colors * sizeof(WORD);
        }
        return size;
    }
    else /* assume BITMAPINFOHEADER */
    {
        colors = max ? (1 << info->bmiHeader.biBitCount) : info->bmiHeader.biClrUsed;
        if (colors > 256)
            colors = 256;
        if (!colors && (info->bmiHeader.biBitCount <= 8))
            colors = 1 << info->bmiHeader.biBitCount;
        if (info->bmiHeader.biCompression == BI_BITFIELDS)
            masks = 3;
        size = max(info->bmiHeader.biSize, sizeof(BITMAPINFOHEADER) + masks * sizeof(DWORD));
        return size + colors * ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
    }
}

UINT FASTCALL DIB_BitmapMaxBitsSize	(	PBITMAPINFO	Info,
		UINT	ScanLines
	)

Definition at line 59 of file bitmap.c.

Referenced by GetDIBits(), and SetDIBitsToDevice().

{
    UINT Ret;

    if (!Info)
        return 0;

    if (Info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
    {
        PBITMAPCOREHEADER Core = (PBITMAPCOREHEADER) Info;
        Ret = WIDTH_BYTES_ALIGN32(Core->bcWidth * Core->bcPlanes,
                Core->bcBitCount) * ScanLines;
    }
    else /* assume BITMAPINFOHEADER */
    {
        if ((Info->bmiHeader.biCompression == BI_RGB) || (Info->bmiHeader.biCompression == BI_BITFIELDS))
        {
            Ret = WIDTH_BYTES_ALIGN32(
                    Info->bmiHeader.biWidth * Info->bmiHeader.biPlanes,
                    Info->bmiHeader.biBitCount) * ScanLines;
        }
        else
        {
            Ret = Info->bmiHeader.biSizeImage;
        }
    }
    return Ret;
}

INT WINAPI DIB_GetBitmapInfo	(	const BITMAPINFOHEADER *	header,
		PLONG	width,
		PLONG	height,
		PWORD	planes,
		PWORD	bpp,
		PLONG	compr,
		PLONG	size
	)

Definition at line 97 of file bitmap.c.

Referenced by CreateDIBitmap().

{
    if (header->biSize == sizeof(BITMAPCOREHEADER))
    {
        BITMAPCOREHEADER *core = (BITMAPCOREHEADER *) header;
        *width = core->bcWidth;
        *height = core->bcHeight;
        *planes = core->bcPlanes;
        *bpp = core->bcBitCount;
        *compr = 0;
        *size = 0;
        return 0;
    }

    if (header->biSize == sizeof(BITMAPINFOHEADER))
    {
        *width = header->biWidth;
        *height = header->biHeight;
        *planes = header->biPlanes;
        *bpp = header->biBitCount;
        *compr = header->biCompression;
        *size = header->biSizeImage;
        return 1;
    }

    if (header->biSize == sizeof(BITMAPV4HEADER))
    {
        BITMAPV4HEADER *v4hdr = (BITMAPV4HEADER *) header;
        *width = v4hdr->bV4Width;
        *height = v4hdr->bV4Height;
        *planes = v4hdr->bV4Planes;
        *bpp = v4hdr->bV4BitCount;
        *compr = v4hdr->bV4V4Compression;
        *size = v4hdr->bV4SizeImage;
        return 4;
    }

    if (header->biSize == sizeof(BITMAPV5HEADER))
    {
        BITMAPV5HEADER *v5hdr = (BITMAPV5HEADER *) header;
        *width = v5hdr->bV5Width;
        *height = v5hdr->bV5Height;
        *planes = v5hdr->bV5Planes;
        *bpp = v5hdr->bV5BitCount;
        *compr = v5hdr->bV5Compression;
        *size = v5hdr->bV5SizeImage;
        return 5;
    }
    DPRINT("(%lu): wrong size for header\n", header->biSize);
    return -1;
}

HBITMAP WINAPI GdiConvertBitmapV5	(	HBITMAP	in_format_BitMap,
		HBITMAP	src_BitMap,
		INT	bpp,
		INT	unuse
	)

Definition at line 931 of file bitmap.c.

{
    /* FIXME guessing the prototypes */

    /*
     * it have create a new bitmap with desired in format,
     * then convert it src_bitmap to new format
     * and return it as HBITMAP
     */

    return FALSE;
}

int WINAPI GdiGetBitmapBitsSize

(

BITMAPINFO *

lpbmi

)

Definition at line 161 of file bitmap.c.

Referenced by ConvertBitmapInfo(), CreateDIBitmap(), and StretchDIBits().

{
    UINT Ret;

    if (!lpbmi)
        return 0;

    if (lpbmi->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
    {
        PBITMAPCOREHEADER Core = (PBITMAPCOREHEADER) lpbmi;
        Ret =
        WIDTH_BYTES_ALIGN32(Core->bcWidth * Core->bcPlanes,
                Core->bcBitCount) * Core->bcHeight;
    }
    else /* assume BITMAPINFOHEADER */
    {
        if (!(lpbmi->bmiHeader.biCompression) || (lpbmi->bmiHeader.biCompression == BI_BITFIELDS))
        {
            Ret = WIDTH_BYTES_ALIGN32(
                    lpbmi->bmiHeader.biWidth * lpbmi->bmiHeader.biPlanes,
                    lpbmi->bmiHeader.biBitCount) * abs(lpbmi->bmiHeader.biHeight);
        }
        else
        {
            Ret = lpbmi->bmiHeader.biSizeImage;
        }
    }
    return Ret;
}

DWORD WINAPI GetBitmapAttributes

(

HBITMAP

hbm

)

Definition at line 894 of file bitmap.c.

{
    UNIMPLEMENTED;
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
}

INT WINAPI GetDIBits	(	HDC	hDC,
		HBITMAP	hbmp,
		UINT	uStartScan,
		UINT	cScanLines,
		LPVOID	lpvBits,
		LPBITMAPINFO	lpbmi,
		UINT	uUsage
	)

Definition at line 354 of file bitmap.c.

Referenced by test_createdibitmap(), test_dib_formats(), test_dibsections(), test_get16dibits(), test_GetDIBits(), test_GetDIBits_BI_BITFIELDS(), test_GetDIBits_scanlines(), test_GetDIBits_selected_DDB(), test_GetDIBits_selected_DIB(), test_GetDIBits_top_down(), and test_GetSetDIBits_rtl().

{
    UINT cjBmpScanSize;
    UINT cjInfoSize;

    if (!hDC || !GdiValidateHandle((HGDIOBJ) hDC) || !lpbmi)
    {
        GdiSetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }

    cjBmpScanSize = DIB_BitmapMaxBitsSize(lpbmi, cScanLines);
    /* Caller must provide maximum size possible */
    cjInfoSize = DIB_BitmapInfoSize(lpbmi, uUsage, TRUE);

    if (lpvBits)
    {
        if (lpbmi->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER))
        {
            if (lpbmi->bmiHeader.biCompression == BI_JPEG
                || lpbmi->bmiHeader.biCompression == BI_PNG)
            {
                SetLastError(ERROR_INVALID_PARAMETER);
                return 0;
            }
        }
    }

    return NtGdiGetDIBitsInternal(hDC, hbmp, uStartScan, cScanLines, lpvBits, lpbmi, uUsage,
        cjBmpScanSize, cjInfoSize);
}

HBITMAP WINAPI SetBitmapAttributes	(	HBITMAP	hbm,
		DWORD	dwFlags
	)

Definition at line 906 of file bitmap.c.

{
    UNIMPLEMENTED;
    SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    return 0;
}

INT WINAPI SetDIBits	(	HDC	hDC,
		HBITMAP	hBitmap,
		UINT	uStartScan,
		UINT	cScanLines,
		CONST VOID *	lpvBits,
		CONST BITMAPINFO *	lpbmi,
		UINT	fuColorUse
	)

Definition at line 562 of file bitmap.c.

Referenced by test_dib_bits_access(), test_dib_formats(), test_GetDIBits(), test_GetSetDIBits_rtl(), test_SetDIBits(), test_SetDIBits_RLE4(), and test_SetDIBits_RLE8().

{
    HDC hDCc, SavehDC, nhDC;
    DWORD dwWidth, dwHeight;
    HGDIOBJ hOldBitmap;
    HPALETTE hPal = NULL;
    INT LinesCopied = 0;
    BOOL newDC = FALSE;

    if (!lpvBits || (GDI_HANDLE_GET_TYPE(hBitmap) != GDI_OBJECT_TYPE_BITMAP))
        return 0;

    if (lpbmi->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER))
    {
        if (lpbmi->bmiHeader.biCompression == BI_JPEG
            || lpbmi->bmiHeader.biCompression == BI_PNG)
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return 0;
        }
    }

    hDCc = NtGdiGetDCforBitmap(hBitmap); // hDC can be NULL, so, get it from the bitmap.
    SavehDC = hDCc;
    if (!hDCc) // No DC associated with bitmap, Clone or Create one.
    {
        nhDC = CreateCompatibleDC(hDC);
        if (!nhDC)
            return 0;
        newDC = TRUE;
        SavehDC = nhDC;
    }
    else if (!SaveDC(hDCc))
        return 0;

    hOldBitmap = SelectObject(SavehDC, hBitmap);

    if (hOldBitmap)
    {
        if (hDC)
            hPal = SelectPalette(SavehDC, (HPALETTE) GetCurrentObject(hDC, OBJ_PAL), FALSE);

        if (lpbmi->bmiHeader.biSize < sizeof(BITMAPINFOHEADER))
        {
            PBITMAPCOREINFO pbci = (PBITMAPCOREINFO) lpbmi;
            dwWidth = pbci->bmciHeader.bcWidth;
            dwHeight = pbci->bmciHeader.bcHeight;
        }
        else
        {
            dwWidth = lpbmi->bmiHeader.biWidth;
            dwHeight = abs(lpbmi->bmiHeader.biHeight);
        }

        LinesCopied = SetDIBitsToDevice(SavehDC, 0, 0, dwWidth, dwHeight, 0, 0, uStartScan,
            cScanLines, (void *) lpvBits, (LPBITMAPINFO) lpbmi, fuColorUse);

        if (hDC)
            SelectPalette(SavehDC, hPal, FALSE);

        SelectObject(SavehDC, hOldBitmap);
    }

    if (newDC)
        DeleteDC(SavehDC);
    else
        RestoreDC(SavehDC, -1);

    return LinesCopied;
}

INT WINAPI SetDIBitsToDevice	(	HDC	hdc,
		int	XDest,
		int	YDest,
		DWORD	Width,
		DWORD	Height,
		int	XSrc,
		int	YSrc,
		UINT	StartScan,
		UINT	ScanLines,
		CONST VOID *	Bits,
		CONST BITMAPINFO *	lpbmi,
		UINT	ColorUse
	)

Definition at line 646 of file bitmap.c.

Referenced by SetDIBits(), test_dib_formats(), test_mono_dibsection(), test_SetDIBitsToDevice(), and test_SetDIBitsToDevice_RLE8().

{
    PDC_ATTR pDc_Attr;
    PBITMAPINFO pConvertedInfo;
    UINT ConvertedInfoSize;
    INT LinesCopied = 0;
    UINT cjBmpScanSize = 0;
    BOOL Hit = FALSE;
    PVOID pvSafeBits = (PVOID) Bits;

    if (!ScanLines || !lpbmi || !Bits)
        return 0;

    if (ColorUse && ColorUse != DIB_PAL_COLORS && ColorUse != DIB_PAL_COLORS + 1)
        return 0;

    pConvertedInfo = ConvertBitmapInfo(lpbmi, ColorUse, &ConvertedInfoSize, FALSE);
    if (!pConvertedInfo)
        return 0;

    HANDLE_METADC(INT,
                  SetDIBitsToDevice,
                  0,
                  hdc,
                  XDest,
                  YDest,
                  Width,
                  Height,
                  XSrc,
                  YSrc,
                  StartScan,
                  ScanLines,
                  Bits,
                  lpbmi,
                  ColorUse);

    if ((pConvertedInfo->bmiHeader.biCompression == BI_RLE8) ||
            (pConvertedInfo->bmiHeader.biCompression == BI_RLE4))
    {
        /* For compressed data, we must set the whole thing */
        StartScan = 0;
        ScanLines = pConvertedInfo->bmiHeader.biHeight;
    }

    cjBmpScanSize = DIB_BitmapMaxBitsSize((LPBITMAPINFO) lpbmi, ScanLines);

    pvSafeBits = RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize);
    if (pvSafeBits)
    {
        _SEH2_TRY
        {
            RtlCopyMemory(pvSafeBits, Bits, cjBmpScanSize);
        }
        _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
        {
            Hit = TRUE;
        }
        _SEH2_END

        if (Hit)
        {
            // We don't die, we continue on with a allocated safe pointer to kernel
            // space.....
            DPRINT1("SetDIBitsToDevice fail to read BitMapInfo: %p or Bits: %p & Size: %u\n",
                pConvertedInfo, Bits, cjBmpScanSize);
        }
        DPRINT("SetDIBitsToDevice Allocate Bits %u!!!\n", cjBmpScanSize);
    }

    if (!GdiGetHandleUserData(hdc, GDI_OBJECT_TYPE_DC, (PVOID) & pDc_Attr))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
    /*
     if ( !pDc_Attr || // DC is Public
     ColorUse == DIB_PAL_COLORS ||
     ((pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER)) &&
     (pConvertedInfo->bmiHeader.biCompression == BI_JPEG ||
     pConvertedInfo->bmiHeader.biCompression  == BI_PNG )) )*/
    {
        LinesCopied = NtGdiSetDIBitsToDeviceInternal(hdc, XDest, YDest, Width, Height, XSrc, YSrc,
            StartScan, ScanLines, (LPBYTE) pvSafeBits, (LPBITMAPINFO) pConvertedInfo, ColorUse,
            cjBmpScanSize, ConvertedInfoSize,
            TRUE,
            NULL);
    }
    if (Bits != pvSafeBits)
        RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits);
    if (lpbmi != pConvertedInfo)
        RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);

    return LinesCopied;
}

int WINAPI StretchDIBits	(	HDC	hdc,
		int	XDest,
		int	YDest,
		int	nDestWidth,
		int	nDestHeight,
		int	XSrc,
		int	YSrc,
		int	nSrcWidth,
		int	nSrcHeight,
		CONST VOID *	lpBits,
		CONST BITMAPINFO *	lpBitsInfo,
		UINT	iUsage,
		DWORD	dwRop
	)

Definition at line 758 of file bitmap.c.

Referenced by check_StretchDIBits_pixel(), check_StretchDIBits_stretch(), and test_dib_formats().

{
    PDC_ATTR pDc_Attr;
    PBITMAPINFO pConvertedInfo = NULL;
    UINT ConvertedInfoSize = 0;
    INT LinesCopied = 0;
    UINT cjBmpScanSize = 0;
    PVOID pvSafeBits = NULL;
    BOOL Hit = FALSE;

    DPRINT("StretchDIBits %p : %p : %u\n", lpBits, lpBitsInfo, iUsage);
#if 0
// Handle something other than a normal dc object.
    if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
    {
        if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
        return MFDRV_StretchBlt( hdc,
                XDest,
                YDest,
                nDestWidth,
                nDestHeight,
                XSrc,
                YSrc,
                nSrcWidth,
                nSrcHeight,
                lpBits,
                lpBitsInfo,
                iUsage,
                dwRop);
        else
        {
            PLDC pLDC = GdiGetLDC(hdc);
            if ( !pLDC )
            {
                SetLastError(ERROR_INVALID_HANDLE);
                return 0;
            }
            if (pLDC->iType == LDC_EMFLDC)
            {
                return EMFDRV_StretchBlt(hdc,
                        XDest,
                        YDest,
                        nDestWidth,
                        nDestHeight,
                        XSrc,
                        YSrc,
                        nSrcWidth,
                        nSrcHeight,
                        lpBits,
                        lpBitsInfo,
                        iUsage,
                        dwRop);
            }
            return 0;
        }
    }
#endif
    pConvertedInfo = ConvertBitmapInfo(lpBitsInfo, iUsage, &ConvertedInfoSize,
        FALSE);
    if (!pConvertedInfo)
    {
        return 0;
    }

    cjBmpScanSize = GdiGetBitmapBitsSize((BITMAPINFO *) pConvertedInfo);

    if (lpBits)
    {
        pvSafeBits = RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize);
        if (pvSafeBits)
        {
            _SEH2_TRY
            {
                RtlCopyMemory(pvSafeBits, lpBits, cjBmpScanSize);
            }
            _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
            {
                Hit = TRUE;
            }
            _SEH2_END

            if (Hit)
            {
                // We don't die, we continue on with a allocated safe pointer to kernel
                // space.....
                DPRINT1("StretchDIBits fail to read BitMapInfo: %p or Bits: %p & Size: %u\n",
                    pConvertedInfo, lpBits, cjBmpScanSize);
            }
            DPRINT("StretchDIBits Allocate Bits %u!!!\n", cjBmpScanSize);
        }
    }

    if (!GdiGetHandleUserData(hdc, GDI_OBJECT_TYPE_DC, (PVOID) & pDc_Attr))
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return 0;
    }
    /*
     if ( !pDc_Attr ||
     iUsage == DIB_PAL_COLORS ||
     ((pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER)) &&
     (pConvertedInfo->bmiHeader.biCompression == BI_JPEG ||
     pConvertedInfo->bmiHeader.biCompression  == BI_PNG )) )*/
    {
        LinesCopied = NtGdiStretchDIBitsInternal(hdc, XDest, YDest, nDestWidth, nDestHeight, XSrc,
            YSrc, nSrcWidth, nSrcHeight, pvSafeBits, pConvertedInfo, (DWORD) iUsage, dwRop,
            ConvertedInfoSize, cjBmpScanSize,
            NULL);
    }
    if (pvSafeBits)
        RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits);
    if (lpBitsInfo != pConvertedInfo)
        RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);

    return LinesCopied;
}