bitmap.c File Reference

#include <stdarg.h>
#include <assert.h>
#include <string.h>
#include "ntstatus.h"
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "wingdi.h"
#include "winuser.h"
#include "mmsystem.h"
#include "wine/winternl.h"
#include "wine/ddk/d3dkmthk.h"
#include "wine/test.h"

Include dependency graph for bitmap.c:

Go to the source code of this file.

Macros
#define	WIN32_NO_STATUS
#define	test_color(hdc, color, exp)   _test_color( __LINE__, hdc, color, exp )
#define	test_mono_1x1_bmp(a)   test_mono_1x1_bmp_dbg((a), __LINE__)

Functions
static	NTSTATUS (WINAPI *pD3DKMTCreateDCFromMemory)(D3DKMT_CREATEDCFROMMEMORY *desc)
static	BOOL (WINAPI *pGdiAlphaBlend)(HDC
static	DWORD (WINAPI *pSetLayout)(HDC hdc
static int	get_bitmap_stride (int width, int bpp)
static int	get_dib_stride (int width, int bpp)
static int	get_dib_image_size (const BITMAPINFO *info)
static void	test_bitmap_info (HBITMAP hbm, INT expected_depth, const BITMAPINFOHEADER *bmih)
static void	test_createdibitmap (void)
static void	test_dib_info (HBITMAP hbm, const void *bits, const BITMAPINFOHEADER *bmih)
static void	_test_color (int line, HDC hdc, COLORREF color, COLORREF exp)
static void	test_dib_bits_access (HBITMAP hdib, void *bits)
static void	test_dibsections (void)
static void	test_dib_formats (void)
static void	test_mono_dibsection (void)
static void	test_bitmap (void)
static COLORREF	get_nearest (int r, int g, int b)
static BOOL	is_black_pen (COLORREF fg, COLORREF bg, int r, int g, int b)
static void	test_bitmap_colors (HDC hdc, COLORREF fg, COLORREF bg, int r, int g, int b)
static void	test_mono_bitmap (void)
static void	test_bmBits (void)
static void	test_GetDIBits_selected_DIB (UINT bpp)
static void	test_GetDIBits_selected_DDB (BOOL monochrome)
static void	test_GetDIBits (void)
static void	test_GetDIBits_BI_BITFIELDS (void)
static void	test_select_object (void)
static void	test_mono_1x1_bmp_dbg (HBITMAP hbmp, int line)
static void	test_CreateBitmap (void)
static void	test_bitmapinfoheadersize (void)
static void	test_get16dibits (void)
static void	check_BitBlt_pixel (HDC hdcDst, HDC hdcSrc, UINT32 *dstBuffer, UINT32 *srcBuffer, DWORD dwRop, UINT32 expected, int line)
static void	test_BitBlt (void)
static void	check_StretchBlt_pixel (HDC hdcDst, HDC hdcSrc, UINT32 *dstBuffer, UINT32 *srcBuffer, DWORD dwRop, UINT32 expected, int line)
static void	check_StretchBlt_stretch (HDC hdcDst, HDC hdcSrc, BITMAPINFO *dst_info, UINT32 *dstBuffer, UINT32 *srcBuffer, int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest, int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc, UINT32 *expected, int line)
static void	test_StretchBlt (void)
static void	check_StretchDIBits_pixel (HDC hdcDst, UINT32 *dstBuffer, UINT32 *srcBuffer, DWORD dwRop, UINT32 expected, int line)
static INT	check_StretchDIBits_stretch (HDC hdcDst, UINT32 *dstBuffer, UINT32 *srcBuffer, int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest, int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc, UINT32 expected[4], int line)
static void	test_StretchDIBits (void)
static void	test_GdiAlphaBlend (void)
static void	test_GdiGradientFill (void)
static void	test_clipping (void)
static void	test_32bit_ddb (void)
static void	setup_picture (char *picture, int bpp)
static void	test_GetDIBits_top_down (int bpp)
static void	test_GetSetDIBits_rtl (void)
static void	test_GetDIBits_scanlines (void)
static void	test_SetDIBits (void)
static void	test_SetDIBits_RLE4 (void)
static void	test_SetDIBits_RLE8 (void)
static void	test_SetDIBitsToDevice (void)
static void	test_SetDIBitsToDevice_RLE8 (void)
static void	test_D3DKMTCreateDCFromMemory (void)
	START_TEST (bitmap)

Variables
static	int
static	HDC
static	BLENDFUNCTION
static TRIVERTEX	ULONG
static DWORD	layout

Macro Definition Documentation

test_color

#define test_color	(		hdc,
			color,
			exp
	)		_test_color( __LINE__, hdc, color, exp )

Definition at line 373 of file bitmap.c.

test_mono_1x1_bmp

#define test_mono_1x1_bmp

(

a

)

test_mono_1x1_bmp_dbg((a), __LINE__)

Definition at line 2769 of file bitmap.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 27 of file bitmap.c.

Function Documentation

_test_color()

static void _test_color ( int  line, HDC  hdc, COLORREF  color, COLORREF  exp  )

static

Definition at line 363 of file bitmap.c.

{
    COLORREF c;
    c = SetPixel(hdc, 0, 0, color);
    ok_(__FILE__, line)(c == exp, "SetPixel failed: got 0x%06x expected 0x%06x\n", c, exp);
    c = GetPixel(hdc, 0, 0);
    ok_(__FILE__, line)(c == exp, "GetPixel failed: got 0x%06x expected 0x%06x\n", c, exp);
    c = GetNearestColor(hdc, color);
    ok_(__FILE__, line)(c == exp, "GetNearestColor failed: got 0x%06x expected 0x%06x\n", c, exp);
}

BOOL()

static BOOL ( WINAPI *  pGdiAlphaBlend )

static

check_BitBlt_pixel()

static void check_BitBlt_pixel ( HDC  hdcDst, HDC  hdcSrc, UINT32 *  dstBuffer, UINT32 *  srcBuffer, DWORD  dwRop, UINT32  expected, int  line  )

static

Definition at line 3013 of file bitmap.c.

{
    *srcBuffer = 0xFEDCBA98;
    *dstBuffer = 0x89ABCDEF;
    BitBlt(hdcDst, 0, 0, 1, 1, hdcSrc, 0, 0, dwRop);
    ok(expected == *dstBuffer,
        "BitBlt with dwRop %06X. Expected 0x%08X, got 0x%08X from line %d\n",
        dwRop, expected, *dstBuffer, line);
}

Referenced by test_BitBlt().

check_StretchBlt_pixel()

static void check_StretchBlt_pixel ( HDC  hdcDst, HDC  hdcSrc, UINT32 *  dstBuffer, UINT32 *  srcBuffer, DWORD  dwRop, UINT32  expected, int  line  )

static

Definition at line 3090 of file bitmap.c.

{
    *srcBuffer = 0xFEDCBA98;
    *dstBuffer = 0x89ABCDEF;
    StretchBlt(hdcDst, 0, 0, 2, 1, hdcSrc, 0, 0, 1, 1, dwRop);
    ok(expected == *dstBuffer,
        "StretchBlt with dwRop %06X. Expected 0x%08X, got 0x%08X from line %d\n",
        dwRop, expected, *dstBuffer, line);
}

Referenced by test_StretchBlt().

check_StretchBlt_stretch()

static void check_StretchBlt_stretch ( HDC  hdcDst, HDC  hdcSrc, BITMAPINFO *  dst_info, UINT32 *  dstBuffer, UINT32 *  srcBuffer, int  nXOriginDest, int  nYOriginDest, int  nWidthDest, int  nHeightDest, int  nXOriginSrc, int  nYOriginSrc, int  nWidthSrc, int  nHeightSrc, UINT32 *  expected, int  line  )

static

Definition at line 3101 of file bitmap.c.

{
    int dst_size = get_dib_image_size( dst_info );

    memset(dstBuffer, 0, dst_size);
    StretchBlt(hdcDst, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
               hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, SRCCOPY);
    ok(memcmp(dstBuffer, expected, dst_size) == 0,
        "StretchBlt expected { %08X, %08X, %08X, %08X } got { %08X, %08X, %08X, %08X } "
        "stretching { %d, %d, %d, %d } to { %d, %d, %d, %d } from line %d\n",
        expected[0], expected[1], expected[2], expected[3],
        dstBuffer[0], dstBuffer[1], dstBuffer[2], dstBuffer[3],
        nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc,
        nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, line);
}

Referenced by test_StretchBlt().

check_StretchDIBits_pixel()

static void check_StretchDIBits_pixel ( HDC  hdcDst, UINT32 *  dstBuffer, UINT32 *  srcBuffer, DWORD  dwRop, UINT32  expected, int  line  )

static

Definition at line 3422 of file bitmap.c.

{
    const UINT32 buffer[2] = { 0xFEDCBA98, 0 };
    BITMAPINFO bitmapInfo;

    memset(&bitmapInfo, 0, sizeof(BITMAPINFO));
    bitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bitmapInfo.bmiHeader.biWidth = 2;
    bitmapInfo.bmiHeader.biHeight = 1;
    bitmapInfo.bmiHeader.biPlanes = 1;
    bitmapInfo.bmiHeader.biBitCount = 32;
    bitmapInfo.bmiHeader.biCompression = BI_RGB;
    bitmapInfo.bmiHeader.biSizeImage = sizeof(buffer);

    *dstBuffer = 0x89ABCDEF;

    StretchDIBits(hdcDst, 0, 0, 2, 1, 0, 0, 1, 1, &buffer, &bitmapInfo, DIB_RGB_COLORS, dwRop);
    ok(expected == *dstBuffer,
        "StretchDIBits with dwRop %06X. Expected 0x%08X, got 0x%08X from line %d\n",
        dwRop, expected, *dstBuffer, line);
}

Referenced by test_StretchDIBits().

check_StretchDIBits_stretch()

static INT check_StretchDIBits_stretch ( HDC  hdcDst, UINT32 *  dstBuffer, UINT32 *  srcBuffer, int  nXOriginDest, int  nYOriginDest, int  nWidthDest, int  nHeightDest, int  nXOriginSrc, int  nYOriginSrc, int  nWidthSrc, int  nHeightSrc, UINT32  expected[4], int  line  )

static

Definition at line 3445 of file bitmap.c.

{
    BITMAPINFO bitmapInfo;
    INT ret;

    memset(&bitmapInfo, 0, sizeof(BITMAPINFO));
    bitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bitmapInfo.bmiHeader.biWidth = 2;
    bitmapInfo.bmiHeader.biHeight = -2;
    bitmapInfo.bmiHeader.biPlanes = 1;
    bitmapInfo.bmiHeader.biBitCount = 32;
    bitmapInfo.bmiHeader.biCompression = BI_RGB;

    memset(dstBuffer, 0, 16);
    ret = StretchDIBits(hdcDst, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
                        nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc,
                        srcBuffer, &bitmapInfo, DIB_RGB_COLORS, SRCCOPY);
    ok(memcmp(dstBuffer, expected, 16) == 0,
        "StretchDIBits expected { %08X, %08X, %08X, %08X } got { %08X, %08X, %08X, %08X } "
        "stretching { %d, %d, %d, %d } to { %d, %d, %d, %d } from line %d\n",
        expected[0], expected[1], expected[2], expected[3],
        dstBuffer[0], dstBuffer[1], dstBuffer[2], dstBuffer[3],
        nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc,
        nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, line);
    return ret;
}

Referenced by test_StretchDIBits().

DWORD()

static DWORD ( WINAPI *  pSetLayout )

static

get_bitmap_stride()

static int get_bitmap_stride ( int  width, int  bpp  )

inlinestatic

Definition at line 48 of file bitmap.c.

{
    return ((width * bpp + 15) >> 3) & ~1;
}

Referenced by test_bitmap_info(), test_dib_info(), test_GetDIBits(), and test_select_object().

get_dib_image_size()

static int get_dib_image_size ( const BITMAPINFO *  info )

inlinestatic

Definition at line 58 of file bitmap.c.

{
    return get_dib_stride( info->bmiHeader.biWidth, info->bmiHeader.biBitCount )
        * abs( info->bmiHeader.biHeight );
}

Referenced by check_StretchBlt_stretch(), and test_StretchBlt().

get_dib_stride()

static int get_dib_stride ( int  width, int  bpp  )

inlinestatic

Definition at line 53 of file bitmap.c.

{
    return ((width * bpp + 31) >> 3) & ~3;
}

Referenced by get_dib_image_size(), test_D3DKMTCreateDCFromMemory(), and test_dib_info().

get_nearest()

static COLORREF get_nearest ( int  r, int  g, int  b  )

static

Definition at line 1602 of file bitmap.c.

{
    return (r*r + g*g + b*b < (255-r)*(255-r) + (255-g)*(255-g) + (255-b)*(255-b)) ? 0x000000 : 0xffffff;
}

Referenced by test_bitmap_colors(), and test_mono_bitmap().

is_black_pen()

static BOOL is_black_pen ( COLORREF  fg, COLORREF  bg, int  r, int  g, int  b  )

static

Definition at line 1607 of file bitmap.c.

{
    if (fg == 0 || bg == 0xffffff) return RGB(r,g,b) != 0xffffff && RGB(r,g,b) != bg;
    return RGB(r,g,b) == 0x000000 || RGB(r,g,b) == bg;
}

Referenced by test_bitmap_colors().

NTSTATUS()

static NTSTATUS ( WINAPI *  pD3DKMTCreateDCFromMemory )

static

setup_picture()

static void setup_picture ( char *  picture, int  bpp  )

static

Definition at line 4087 of file bitmap.c.

{
    int i;

    switch(bpp)
    {
        case 16:
        case 32:
            /*Set the first byte in each pixel to the index of that pixel.*/
            for (i = 0; i < 4; i++)
                picture[i * (bpp / 8)] = i;
            break;
        case 24:
            picture[0] = 0;
            picture[3] = 1;
            /*Each scanline in a bitmap must be a multiple of 4 bytes long.*/
            picture[8] = 2;
            picture[11] = 3;
            break;
    }
}

Referenced by test_GetDIBits_top_down().

START_TEST()

START_TEST

(

bitmap

)

Definition at line 5941 of file bitmap.c.

{
    HMODULE hdll;

    hdll = GetModuleHandleA("gdi32.dll");
#ifndef __REACTOS__ /* CORE-11331 */
    pD3DKMTCreateDCFromMemory  = (void *)GetProcAddress( hdll, "D3DKMTCreateDCFromMemory" );
    pD3DKMTDestroyDCFromMemory = (void *)GetProcAddress( hdll, "D3DKMTDestroyDCFromMemory" );
#endif
    pGdiAlphaBlend             = (void *)GetProcAddress( hdll, "GdiAlphaBlend" );
    pGdiGradientFill           = (void *)GetProcAddress( hdll, "GdiGradientFill" );
    pSetLayout                 = (void *)GetProcAddress( hdll, "SetLayout" );

    test_createdibitmap();
    test_dibsections();
    test_dib_formats();
    test_mono_dibsection();
    test_bitmap();
    test_mono_bitmap();
    test_bmBits();
    test_GetDIBits_selected_DIB(1);
    test_GetDIBits_selected_DIB(4);
    test_GetDIBits_selected_DIB(8);
    test_GetDIBits_selected_DDB(TRUE);
    test_GetDIBits_selected_DDB(FALSE);
    test_GetDIBits();
    test_GetDIBits_BI_BITFIELDS();
    test_select_object();
    test_CreateBitmap();
    test_BitBlt();
    test_StretchBlt();
    test_StretchDIBits();
    test_GdiAlphaBlend();
    test_GdiGradientFill();
    test_32bit_ddb();
    test_bitmapinfoheadersize();
    test_get16dibits();
    test_clipping();
    test_GetDIBits_top_down(16);
    test_GetDIBits_top_down(24);
    test_GetDIBits_top_down(32);
    test_GetSetDIBits_rtl();
    test_GetDIBits_scanlines();
    test_SetDIBits();
    test_SetDIBits_RLE4();
    test_SetDIBits_RLE8();
    test_SetDIBitsToDevice();
    test_SetDIBitsToDevice_RLE8();
#ifndef __REACTOS__ /* CORE-11331 */
    test_D3DKMTCreateDCFromMemory();
#endif
}

test_32bit_ddb()

static void test_32bit_ddb ( void  )

static

Definition at line 3992 of file bitmap.c.

{
    char buffer[sizeof(BITMAPINFOHEADER) + sizeof(DWORD)];
    BITMAPINFO *biDst = (BITMAPINFO *)buffer;
    HBITMAP bmpSrc, bmpDst;
    HBITMAP oldSrc, oldDst;
    HDC hdcSrc, hdcDst, hdcScreen;
    HBRUSH brush;
    DWORD *dstBuffer, *data;
    DWORD colorSrc = 0x40201008;

    memset(biDst, 0, sizeof(BITMAPINFOHEADER));
    biDst->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    biDst->bmiHeader.biWidth = 1;
    biDst->bmiHeader.biHeight = -1;
    biDst->bmiHeader.biPlanes = 1;
    biDst->bmiHeader.biBitCount = 32;
    biDst->bmiHeader.biCompression = BI_RGB;

    hdcScreen = CreateCompatibleDC(0);
    if(GetDeviceCaps(hdcScreen, BITSPIXEL) != 32)
    {
        DeleteDC(hdcScreen);
        trace("Skipping 32-bit DDB test\n");
        return;
    }

    hdcSrc = CreateCompatibleDC(hdcScreen);
    bmpSrc = CreateBitmap(1, 1, 1, 32, &colorSrc);
    oldSrc = SelectObject(hdcSrc, bmpSrc);

    hdcDst = CreateCompatibleDC(hdcScreen);
    bmpDst = CreateDIBSection(hdcDst, biDst, DIB_RGB_COLORS, (void**)&dstBuffer, NULL, 0);
    oldDst = SelectObject(hdcDst, bmpDst);

    StretchBlt(hdcDst, 0, 0, 1, 1, hdcSrc, 0, 0, 1, 1, SRCCOPY);
    ok(dstBuffer[0] == colorSrc, "Expected color=%x, received color=%x\n", colorSrc, dstBuffer[0]);

    if (pGdiAlphaBlend)
    {
        BLENDFUNCTION blend;
        BOOL ret;

        blend.BlendOp = AC_SRC_OVER;
        blend.BlendFlags = 0;
        blend.SourceConstantAlpha = 128;
        blend.AlphaFormat = 0;
        dstBuffer[0] = 0x80808080;
        ret = pGdiAlphaBlend( hdcDst, 0, 0, 1, 1, hdcSrc, 0, 0, 1, 1, blend );
        ok( ret, "GdiAlphaBlend failed err %u\n", GetLastError() );
        ok(dstBuffer[0] == 0x60504844, "wrong color %x\n", dstBuffer[0]);
        blend.AlphaFormat = AC_SRC_ALPHA;
        dstBuffer[0] = 0x80808080;
        ret = pGdiAlphaBlend( hdcDst, 0, 0, 1, 1, hdcSrc, 0, 0, 1, 1, blend );
        ok( ret, "GdiAlphaBlend failed err %u\n", GetLastError() );
        ok(dstBuffer[0] == 0x90807874, "wrong color %x\n", dstBuffer[0]);
    }

    data = (DWORD *)biDst->bmiColors;
    data[0] = 0x20304050;
    brush = CreateDIBPatternBrushPt( biDst, DIB_RGB_COLORS );
    ok( brush != 0, "brush creation failed\n" );
    SelectObject( hdcSrc, brush );
    PatBlt( hdcSrc, 0, 0, 1, 1, PATCOPY );
    BitBlt( hdcDst, 0, 0, 1, 1, hdcSrc, 0, 0, SRCCOPY );
    ok(dstBuffer[0] == data[0], "Expected color=%x, received color=%x\n", data[0], dstBuffer[0]);
    SelectObject( hdcSrc, GetStockObject(BLACK_BRUSH) );
    DeleteObject( brush );

    biDst->bmiHeader.biBitCount = 24;
    brush = CreateDIBPatternBrushPt( biDst, DIB_RGB_COLORS );
    ok( brush != 0, "brush creation failed\n" );
    SelectObject( hdcSrc, brush );
    PatBlt( hdcSrc, 0, 0, 1, 1, PATCOPY );
    BitBlt( hdcDst, 0, 0, 1, 1, hdcSrc, 0, 0, SRCCOPY );
    ok(dstBuffer[0] == (data[0] & ~0xff000000),
       "Expected color=%x, received color=%x\n", data[0] & 0xff000000, dstBuffer[0]);
    SelectObject( hdcSrc, GetStockObject(BLACK_BRUSH) );
    DeleteObject( brush );

    /* Tidy up */
    SelectObject(hdcDst, oldDst);
    DeleteObject(bmpDst);
    DeleteDC(hdcDst);

    SelectObject(hdcSrc, oldSrc);
    DeleteObject(bmpSrc);
    DeleteDC(hdcSrc);

    DeleteDC(hdcScreen);
}

Referenced by START_TEST().

test_BitBlt()

static void test_BitBlt ( void  )

static

Definition at line 3024 of file bitmap.c.

{
    HBITMAP bmpDst, bmpSrc;
    HBITMAP oldDst, oldSrc;
    HDC hdcScreen, hdcDst, hdcSrc;
    UINT32 *dstBuffer, *srcBuffer;
    HBRUSH hBrush, hOldBrush;
    BITMAPINFO bitmapInfo;

    memset(&bitmapInfo, 0, sizeof(BITMAPINFO));
    bitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bitmapInfo.bmiHeader.biWidth = 1;
    bitmapInfo.bmiHeader.biHeight = 1;
    bitmapInfo.bmiHeader.biPlanes = 1;
    bitmapInfo.bmiHeader.biBitCount = 32;
    bitmapInfo.bmiHeader.biCompression = BI_RGB;
    bitmapInfo.bmiHeader.biSizeImage = sizeof(UINT32);

    hdcScreen = CreateCompatibleDC(0);
    hdcDst = CreateCompatibleDC(hdcScreen);
    hdcSrc = CreateCompatibleDC(hdcDst);

    /* Setup the destination dib section */
    bmpDst = CreateDIBSection(hdcScreen, &bitmapInfo, DIB_RGB_COLORS, (void**)&dstBuffer,
        NULL, 0);
    oldDst = SelectObject(hdcDst, bmpDst);

    hBrush = CreateSolidBrush(0x12345678);
    hOldBrush = SelectObject(hdcDst, hBrush);

    /* Setup the source dib section */
    bmpSrc = CreateDIBSection(hdcScreen, &bitmapInfo, DIB_RGB_COLORS, (void**)&srcBuffer,
        NULL, 0);
    oldSrc = SelectObject(hdcSrc, bmpSrc);

    check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, SRCCOPY, 0xFEDCBA98, __LINE__);
    check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, SRCPAINT, 0xFFFFFFFF, __LINE__);
    check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, SRCAND, 0x88888888, __LINE__);
    check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, SRCINVERT, 0x77777777, __LINE__);
    check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, SRCERASE, 0x76543210, __LINE__);
    check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, NOTSRCCOPY, 0x01234567, __LINE__);
    check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, NOTSRCERASE, 0x00000000, __LINE__);
    check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, MERGECOPY, 0x00581210, __LINE__);
    check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, MERGEPAINT, 0x89ABCDEF, __LINE__);
    check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, PATCOPY, 0x00785634, __LINE__);
    check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, PATPAINT, 0x89FBDFFF, __LINE__);
    check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, PATINVERT, 0x89D39BDB, __LINE__);
    check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, DSTINVERT, 0x76543210, __LINE__);
    check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, BLACKNESS, 0x00000000, __LINE__);
    check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, WHITENESS, 0xFFFFFFFF, __LINE__);

    /* Tidy up */
    SelectObject(hdcSrc, oldSrc);
    DeleteObject(bmpSrc);
    DeleteDC(hdcSrc);

    SelectObject(hdcDst, hOldBrush);
    DeleteObject(hBrush);
    SelectObject(hdcDst, oldDst);
    DeleteObject(bmpDst);
    DeleteDC(hdcDst);


    DeleteDC(hdcScreen);
}

Referenced by START_TEST().

test_bitmap()

static void test_bitmap ( void  )

static

Definition at line 1493 of file bitmap.c.

{
    char buf[256], buf_cmp[256];
    HBITMAP hbmp, hbmp_old;
    HDC hdc;
    BITMAP bm;
    BITMAP bma[2];
    INT ret;

    hdc = CreateCompatibleDC(0);
    assert(hdc != 0);

    SetLastError(0xdeadbeef);
    hbmp = CreateBitmap(0x7ffffff, 1, 1, 1, NULL);
    if (!hbmp)
    {
        ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY /* XP */ ||
           GetLastError() == ERROR_INVALID_PARAMETER /* Win2k */,
           "expected ERROR_NOT_ENOUGH_MEMORY, got %u\n", GetLastError());
    }
    else
        DeleteObject(hbmp);

    SetLastError(0xdeadbeef);
    hbmp = CreateBitmap(0x7ffffff, 9, 1, 1, NULL);
    if (!hbmp)
    {
        ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY /* XP */ ||
           GetLastError() == ERROR_INVALID_PARAMETER /* Win2k */,
           "expected ERROR_NOT_ENOUGH_MEMORY, got %u\n", GetLastError());
    }
    else
        DeleteObject(hbmp);

    SetLastError(0xdeadbeef);
    hbmp = CreateBitmap(0x7ffffff + 1, 1, 1, 1, NULL);
    ok(!hbmp, "CreateBitmap should fail\n");
    if (!hbmp)
        ok(GetLastError() == ERROR_INVALID_PARAMETER,
           "expected ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
    else
        DeleteObject(hbmp);

    hbmp = CreateBitmap(15, 15, 1, 1, NULL);
    assert(hbmp != NULL);

    ret = GetObjectW(hbmp, sizeof(bm), &bm);
    ok(ret == sizeof(bm), "wrong size %d\n", ret);

    ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
    ok(bm.bmWidth == 15, "wrong bm.bmWidth %d\n", bm.bmWidth);
    ok(bm.bmHeight == 15, "wrong bm.bmHeight %d\n", bm.bmHeight);
    ok(bm.bmWidthBytes == 2, "wrong bm.bmWidthBytes %d\n", bm.bmWidthBytes);
    ok(bm.bmPlanes == 1, "wrong bm.bmPlanes %d\n", bm.bmPlanes);
    ok(bm.bmBitsPixel == 1, "wrong bm.bmBitsPixel %d\n", bm.bmBitsPixel);
    ok(bm.bmBits == NULL, "wrong bm.bmBits %p\n", bm.bmBits);

    assert(sizeof(buf) >= bm.bmWidthBytes * bm.bmHeight);
    assert(sizeof(buf) == sizeof(buf_cmp));

    ret = GetBitmapBits(hbmp, 0, NULL);
    ok(ret == bm.bmWidthBytes * bm.bmHeight, "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);

    memset(buf_cmp, 0xAA, sizeof(buf_cmp));
    memset(buf_cmp, 0, bm.bmWidthBytes * bm.bmHeight);

    memset(buf, 0xAA, sizeof(buf));
    ret = GetBitmapBits(hbmp, sizeof(buf), buf);
    ok(ret == bm.bmWidthBytes * bm.bmHeight, "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
    ok(!memcmp(buf, buf_cmp, sizeof(buf)), "buffers do not match\n");

    hbmp_old = SelectObject(hdc, hbmp);

    ret = GetObjectW(hbmp, sizeof(bm), &bm);
    ok(ret == sizeof(bm), "wrong size %d\n", ret);

    ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
    ok(bm.bmWidth == 15, "wrong bm.bmWidth %d\n", bm.bmWidth);
    ok(bm.bmHeight == 15, "wrong bm.bmHeight %d\n", bm.bmHeight);
    ok(bm.bmWidthBytes == 2, "wrong bm.bmWidthBytes %d\n", bm.bmWidthBytes);
    ok(bm.bmPlanes == 1, "wrong bm.bmPlanes %d\n", bm.bmPlanes);
    ok(bm.bmBitsPixel == 1, "wrong bm.bmBitsPixel %d\n", bm.bmBitsPixel);
    ok(bm.bmBits == NULL, "wrong bm.bmBits %p\n", bm.bmBits);

    memset(buf, 0xAA, sizeof(buf));
    ret = GetBitmapBits(hbmp, sizeof(buf), buf);
    ok(ret == bm.bmWidthBytes * bm.bmHeight, "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
    ok(!memcmp(buf, buf_cmp, sizeof(buf)), "buffers do not match\n");

    hbmp_old = SelectObject(hdc, hbmp_old);
    ok(hbmp_old == hbmp, "wrong old bitmap %p\n", hbmp_old);

    /* test various buffer sizes for GetObject */
    ret = GetObjectW(hbmp, sizeof(*bma) * 2, bma);
    ok(ret == sizeof(*bma), "wrong size %d\n", ret);

    ret = GetObjectW(hbmp, sizeof(bm) / 2, &bm);
    ok(ret == 0, "%d != 0\n", ret);

    ret = GetObjectW(hbmp, 0, &bm);
    ok(ret == 0, "%d != 0\n", ret);

    ret = GetObjectW(hbmp, 1, &bm);
    ok(ret == 0, "%d != 0\n", ret);

    DeleteObject(hbmp);
    DeleteDC(hdc);
}

Referenced by START_TEST().

test_bitmap_colors()

static void test_bitmap_colors ( HDC  hdc, COLORREF  fg, COLORREF  bg, int  r, int  g, int  b  )

static

Definition at line 1613 of file bitmap.c.

{
    static const WORD pattern_bits[] = { 0x5555, 0xaaaa, 0x5555, 0xaaaa, 0x5555, 0xaaaa, 0x5555, 0xaaaa };
    char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors ) + 256 * sizeof(RGBQUAD)];
    BITMAPINFO *info = (BITMAPINFO *)buffer;
    RGBQUAD *colors = info->bmiColors;
    WORD bits[16];
    void *bits_ptr;
    COLORREF res;
    HBRUSH old_brush;
    HPEN old_pen;
    HBITMAP bitmap;
    HDC memdc;

    res = SetPixel( hdc, 0, 0, RGB(r,g,b) );
    ok( res == get_nearest( r, g, b ),
        "wrong result %06x for %02x,%02x,%02x fg %06x bg %06x\n", res, r, g, b, fg, bg );
    res = GetPixel( hdc, 0, 0 );
    ok( res == get_nearest( r, g, b ),
        "wrong result %06x for %02x,%02x,%02x fg %06x bg %06x\n", res, r, g, b, fg, bg );
    res = GetNearestColor( hdc, RGB(r,g,b) );
    ok( res == get_nearest( r, g, b ),
        "wrong result %06x for %02x,%02x,%02x fg %06x bg %06x\n", res, r, g, b, fg, bg );

    /* solid pen */
    old_pen = SelectObject( hdc, CreatePen( PS_SOLID, 1, RGB(r,g,b) ));
    MoveToEx( hdc, 0, 0, NULL );
    LineTo( hdc, 16, 0 );
    res = GetPixel( hdc, 0, 0 );
    ok( res == (is_black_pen( fg, bg, r, g, b ) ? 0 : 0xffffff),
        "wrong result %06x for %02x,%02x,%02x fg %06x bg %06x\n", res, r, g, b, fg, bg );
    GetBitmapBits( GetCurrentObject( hdc, OBJ_BITMAP ), sizeof(bits), bits );
    ok( bits[0] == (is_black_pen( fg, bg, r, g, b ) ? 0x00 : 0xffff),
        "wrong bits %04x for %02x,%02x,%02x fg %06x bg %06x\n", bits[0], r, g, b, fg, bg );
    DeleteObject( SelectObject( hdc, old_pen ));

    /* mono DDB pattern brush */
    bitmap = CreateBitmap( 16, 8, 1, 1, pattern_bits );
    old_brush = SelectObject( hdc, CreatePatternBrush( bitmap ));
    PatBlt( hdc, 0, 0, 16, 16, PATCOPY );
    GetBitmapBits( GetCurrentObject( hdc, OBJ_BITMAP ), sizeof(bits), bits );
    ok( bits[0] == 0x5555 || broken(bits[0] == 0xaada) /* XP SP1 & 2003 SP0 */,
        "wrong bits %04x for %02x,%02x,%02x fg %06x bg %06x\n", bits[0], r, g, b, fg, bg );
    DeleteObject( SelectObject( hdc, old_brush ));

    /* mono DDB bitmap */
    memdc = CreateCompatibleDC( hdc );
    SelectObject( memdc, bitmap );
    BitBlt( hdc, 0, 0, 16, 8, memdc, 0, 0, SRCCOPY );
    GetBitmapBits( GetCurrentObject( hdc, OBJ_BITMAP ), sizeof(bits), bits );
    ok( bits[0] == 0x5555,
        "wrong bits %04x for %02x,%02x,%02x fg %06x bg %06x\n", bits[0], r, g, b, fg, bg );
    SetTextColor( memdc, RGB(255,255,255) );
    SetBkColor( memdc, RGB(0,0,0) );
    BitBlt( hdc, 0, 0, 16, 8, memdc, 0, 0, SRCCOPY );
    GetBitmapBits( GetCurrentObject( hdc, OBJ_BITMAP ), sizeof(bits), bits );
    ok( bits[0] == 0x5555,
        "wrong bits %04x for %02x,%02x,%02x fg %06x bg %06x\n", bits[0], r, g, b, fg, bg );

    /* mono DIB section */
    memset( buffer, 0, sizeof(buffer) );
    info->bmiHeader.biSize = sizeof(info->bmiHeader);
    info->bmiHeader.biHeight = -16;
    info->bmiHeader.biWidth = 16;
    info->bmiHeader.biBitCount = 1;
    info->bmiHeader.biPlanes = 1;
    info->bmiHeader.biCompression = BI_RGB;
    colors[0].rgbRed = 0xff;
    colors[0].rgbGreen = 0xff;
    colors[0].rgbBlue = 0xf0;
    colors[1].rgbRed = 0x20;
    colors[1].rgbGreen = 0x0;
    colors[1].rgbBlue = 0x0;
    bitmap = CreateDIBSection( 0, info, DIB_RGB_COLORS, &bits_ptr, NULL, 0 );
    memset( bits_ptr, 0x55, 64 );
    DeleteObject( SelectObject( memdc, bitmap ));
    BitBlt( hdc, 0, 0, 16, 8, memdc, 0, 0, SRCCOPY );
    GetBitmapBits( GetCurrentObject( hdc, OBJ_BITMAP ), sizeof(bits), bits );
    ok( bits[0] == 0x5555,
        "wrong bits %04x for %02x,%02x,%02x fg %06x bg %06x\n", bits[0], r, g, b, fg, bg );

    colors[0].rgbRed = 0x0;
    colors[0].rgbGreen = 0x0;
    colors[0].rgbBlue = 0x10;
    colors[1].rgbRed = 0xff;
    colors[1].rgbGreen = 0xf0;
    colors[1].rgbBlue = 0xff;
    bitmap = CreateDIBSection( 0, info, DIB_RGB_COLORS, &bits_ptr, NULL, 0 );
    memset( bits_ptr, 0x55, 64 );
    DeleteObject( SelectObject( memdc, bitmap ));
    BitBlt( hdc, 0, 0, 16, 8, memdc, 0, 0, SRCCOPY );
    GetBitmapBits( GetCurrentObject( hdc, OBJ_BITMAP ), sizeof(bits), bits );
    ok( bits[0] == 0xaaaa,
        "wrong bits %04x for %02x,%02x,%02x fg %06x bg %06x\n", bits[0], r, g, b, fg, bg );

    SetTextColor( memdc, RGB(0,20,0) );
    SetBkColor( memdc, RGB(240,240,240) );
    BitBlt( hdc, 0, 0, 16, 8, memdc, 0, 0, SRCCOPY );
    GetBitmapBits( GetCurrentObject( hdc, OBJ_BITMAP ), sizeof(bits), bits );
    ok( bits[0] == 0x5555,
        "wrong bits %04x for %02x,%02x,%02x fg %06x bg %06x\n", bits[0], r, g, b, fg, bg );

    SetTextColor( memdc, RGB(250,250,250) );
    SetBkColor( memdc, RGB(10,10,10) );
    BitBlt( hdc, 0, 0, 16, 8, memdc, 0, 0, SRCCOPY );
    GetBitmapBits( GetCurrentObject( hdc, OBJ_BITMAP ), sizeof(bits), bits );
    ok( bits[0] == 0xaaaa,
        "wrong bits %04x for %02x,%02x,%02x fg %06x bg %06x\n", bits[0], r, g, b, fg, bg );
    DeleteDC( memdc );
    DeleteObject( bitmap );
}

Referenced by test_mono_bitmap().

test_bitmap_info()

static void test_bitmap_info ( HBITMAP  hbm, INT  expected_depth, const BITMAPINFOHEADER *  bmih  )

static

Definition at line 64 of file bitmap.c.

{
    BITMAP bm;
    BITMAP bma[2];
    INT ret, width_bytes, i;
    BYTE buf[512], buf_cmp[512];
    INT test_size[] = {0 /*first value will be changed */, 0, -1, -1000, ~0, sizeof(buf)};

    ret = GetObjectW(hbm, sizeof(bm), &bm);
    ok(ret == sizeof(bm), "GetObject returned %d\n", ret);

    ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
    ok(bm.bmWidth == bmih->biWidth, "wrong bm.bmWidth %d\n", bm.bmWidth);
    ok(bm.bmHeight == bmih->biHeight, "wrong bm.bmHeight %d\n", bm.bmHeight);
    width_bytes = get_bitmap_stride(bm.bmWidth, bm.bmBitsPixel);
    ok(bm.bmWidthBytes == width_bytes, "wrong bm.bmWidthBytes %d != %d\n", bm.bmWidthBytes, width_bytes);
    ok(bm.bmPlanes == bmih->biPlanes, "wrong bm.bmPlanes %d\n", bm.bmPlanes);
    ok(bm.bmBitsPixel == expected_depth, "wrong bm.bmBitsPixel %d != %d\n", bm.bmBitsPixel, expected_depth);
    ok(bm.bmBits == NULL, "wrong bm.bmBits %p\n", bm.bmBits);

    assert(sizeof(buf) >= bm.bmWidthBytes * bm.bmHeight);
    assert(sizeof(buf) == sizeof(buf_cmp));

    SetLastError(0xdeadbeef);
    test_size[0] = bm.bmWidthBytes * bm.bmHeight;
    /* NULL output buffer with different count values */
    for (i = 0; i < sizeof(test_size) / sizeof(test_size[0]); i++)
    {
        ret = GetBitmapBits(hbm, test_size[i], NULL);
        ok(ret == bm.bmWidthBytes * bm.bmHeight, "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
    }

    memset(buf_cmp, 0xAA, sizeof(buf_cmp));
    memset(buf_cmp, 0, bm.bmWidthBytes * bm.bmHeight);

    /* Correct output buffer with different count values */
    for (i = 0; i < sizeof(test_size) / sizeof(test_size[0]); i++)
    {
        int expect = i == 1 ? 0 : bm.bmWidthBytes * bm.bmHeight;
        memset(buf, 0xAA, sizeof(buf));
        ret = GetBitmapBits(hbm, test_size[i], buf);
        ok(ret == expect, "Test[%d]: %d != %d\n", i, ret, expect);
        if (expect)
            ok(!memcmp(buf, buf_cmp, sizeof(buf)),
               "Test[%d]: buffers do not match, depth %d\n", i, bmih->biBitCount);
    }

    /* test various buffer sizes for GetObject */
    ret = GetObjectW(hbm, sizeof(*bma) * 2, bma);
    ok(ret == sizeof(*bma), "wrong size %d\n", ret);

    ret = GetObjectW(hbm, sizeof(bm) / 2, &bm);
    ok(ret == 0, "%d != 0\n", ret);

    ret = GetObjectW(hbm, 0, &bm);
    ok(ret == 0, "%d != 0\n", ret);

    ret = GetObjectW(hbm, 1, &bm);
    ok(ret == 0, "%d != 0\n", ret);

    ret = GetObjectW(hbm, 0, NULL);
    ok(ret == sizeof(bm), "wrong size %d\n", ret);
}

Referenced by test_createdibitmap().

test_bitmapinfoheadersize()

static void test_bitmapinfoheadersize ( void  )

static

Definition at line 2874 of file bitmap.c.

{
    HBITMAP hdib;
    BITMAPINFO bmi;
    BITMAPCOREINFO bci;
    HDC hdc = GetDC(0);

    memset(&bmi, 0, sizeof(BITMAPINFO));
    bmi.bmiHeader.biHeight = 100;
    bmi.bmiHeader.biWidth = 512;
    bmi.bmiHeader.biBitCount = 24;
    bmi.bmiHeader.biPlanes = 1;

    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER) - 1;

    hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
    ok(hdib == NULL, "CreateDIBSection succeeded\n");

    bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);

    SetLastError(0xdeadbeef);
    hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
    ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
    DeleteObject(hdib);

    bmi.bmiHeader.biSize++;

    SetLastError(0xdeadbeef);
    hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
    ok(hdib != NULL ||
       broken(!hdib), /* Win98, WinMe */
       "CreateDIBSection error %d\n", GetLastError());
    DeleteObject(hdib);

    bmi.bmiHeader.biSize = sizeof(BITMAPINFO);

    SetLastError(0xdeadbeef);
    hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
    ok(hdib != NULL ||
       broken(!hdib), /* Win98, WinMe */
       "CreateDIBSection error %d\n", GetLastError());
    DeleteObject(hdib);

    bmi.bmiHeader.biSize++;

    SetLastError(0xdeadbeef);
    hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
    ok(hdib != NULL ||
       broken(!hdib), /* Win98, WinMe */
       "CreateDIBSection error %d\n", GetLastError());
    DeleteObject(hdib);

    bmi.bmiHeader.biSize = sizeof(BITMAPV4HEADER);

    SetLastError(0xdeadbeef);
    hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
    ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
    DeleteObject(hdib);

    bmi.bmiHeader.biSize = sizeof(BITMAPV5HEADER);

    SetLastError(0xdeadbeef);
    hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
    ok(hdib != NULL ||
       broken(!hdib), /* Win95 */
       "CreateDIBSection error %d\n", GetLastError());
    DeleteObject(hdib);

    memset(&bci, 0, sizeof(BITMAPCOREINFO));
    bci.bmciHeader.bcHeight = 100;
    bci.bmciHeader.bcWidth = 512;
    bci.bmciHeader.bcBitCount = 24;
    bci.bmciHeader.bcPlanes = 1;

    bci.bmciHeader.bcSize = sizeof(BITMAPCOREHEADER) - 1;

    hdib = CreateDIBSection(hdc, (BITMAPINFO *)&bci, 0, NULL, NULL, 0);
    ok(hdib == NULL, "CreateDIBSection succeeded\n");

    bci.bmciHeader.bcSize = sizeof(BITMAPCOREHEADER);

    SetLastError(0xdeadbeef);
    hdib = CreateDIBSection(hdc, (BITMAPINFO *)&bci, 0, NULL, NULL, 0);
    ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
    DeleteObject(hdib);

    bci.bmciHeader.bcSize++;

    hdib = CreateDIBSection(hdc, (BITMAPINFO *)&bci, 0, NULL, NULL, 0);
    ok(hdib == NULL, "CreateDIBSection succeeded\n");

    bci.bmciHeader.bcSize = sizeof(BITMAPCOREINFO);

    hdib = CreateDIBSection(hdc, (BITMAPINFO *)&bci, 0, NULL, NULL, 0);
    ok(hdib == NULL, "CreateDIBSection succeeded\n");

    ReleaseDC(0, hdc);
}

Referenced by START_TEST().

test_bmBits()

static void test_bmBits ( void  )

static

Definition at line 1785 of file bitmap.c.

{
    BYTE bits[4];
    HBITMAP hbmp;
    BITMAP bmp;

    memset(bits, 0, sizeof(bits));
    hbmp = CreateBitmap(2, 2, 1, 4, bits);
    ok(hbmp != NULL, "CreateBitmap failed\n");

    memset(&bmp, 0xFF, sizeof(bmp));
    ok(GetObjectW(hbmp, sizeof(bmp), &bmp) == sizeof(bmp),
       "GetObject failed or returned a wrong structure size\n");
    ok(!bmp.bmBits, "bmBits must be NULL for device-dependent bitmaps\n");

    DeleteObject(hbmp);
}

Referenced by START_TEST().

test_clipping()

static void test_clipping ( void  )

static

Definition at line 3949 of file bitmap.c.

{
    HBITMAP bmpDst;
    HBITMAP bmpSrc;
    HRGN hRgn;
    LPVOID bits;
    BOOL result;

    HDC hdcDst = CreateCompatibleDC( NULL );
    HDC hdcSrc = CreateCompatibleDC( NULL );

    BITMAPINFO bmpinfo={{0}};
    bmpinfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bmpinfo.bmiHeader.biWidth = 100;
    bmpinfo.bmiHeader.biHeight = 100;
    bmpinfo.bmiHeader.biPlanes = 1;
    bmpinfo.bmiHeader.biBitCount = GetDeviceCaps( hdcDst, BITSPIXEL );
    bmpinfo.bmiHeader.biCompression = BI_RGB;

    bmpDst = CreateDIBSection( hdcDst, &bmpinfo, DIB_RGB_COLORS, &bits, NULL, 0 );
    ok(bmpDst != NULL, "Couldn't create destination bitmap\n");
    SelectObject( hdcDst, bmpDst );

    bmpSrc = CreateDIBSection( hdcSrc, &bmpinfo, DIB_RGB_COLORS, &bits, NULL, 0 );
    ok(bmpSrc != NULL, "Couldn't create source bitmap\n");
    SelectObject( hdcSrc, bmpSrc );

    result = BitBlt( hdcDst, 0, 0, 100, 100, hdcSrc, 100, 100, SRCCOPY );
    ok(result, "BitBlt failed\n");

    hRgn = CreateRectRgn( 0,0,0,0 );
    SelectClipRgn( hdcDst, hRgn );

    result = BitBlt( hdcDst, 0, 0, 100, 100, hdcSrc, 0, 0, SRCCOPY );
    ok(result, "BitBlt failed\n");

    DeleteObject( bmpDst );
    DeleteObject( bmpSrc );
    DeleteObject( hRgn );
    DeleteDC( hdcDst );
    DeleteDC( hdcSrc );
}

Referenced by START_TEST().

test_CreateBitmap()

static void test_CreateBitmap ( void  )

static

Definition at line 2771 of file bitmap.c.

{
    BITMAP bmp;
    HDC screenDC = GetDC(0);
    HDC hdc = CreateCompatibleDC(screenDC);
    UINT i, expect = 0;

    /* all of these are the stock monochrome bitmap */
    HBITMAP bm = CreateCompatibleBitmap(hdc, 0, 0);
    HBITMAP bm1 = CreateCompatibleBitmap(screenDC, 0, 0);
    HBITMAP bm4 = CreateBitmap(0, 1, 0, 0, 0);
    HBITMAP bm5 = CreateDiscardableBitmap(hdc, 0, 0);
    HBITMAP curObj1 = GetCurrentObject(hdc, OBJ_BITMAP);
    HBITMAP curObj2 = GetCurrentObject(screenDC, OBJ_BITMAP);

    /* these 2 are not the stock monochrome bitmap */
    HBITMAP bm2 = CreateCompatibleBitmap(hdc, 1, 1);
    HBITMAP bm3 = CreateBitmap(1, 1, 1, 1, 0);

    HBITMAP old1 = SelectObject(hdc, bm2);
    HBITMAP old2 = SelectObject(screenDC, bm3);
    SelectObject(hdc, old1);
    SelectObject(screenDC, old2);

    ok(bm == bm1 && bm == bm4 && bm == bm5 && bm == curObj1 && bm == old1,
       "0: %p, 1: %p, 4: %p, 5: %p, curObj1 %p, old1 %p\n",
       bm, bm1, bm4, bm5, curObj1, old1);
    ok(bm != bm2 && bm != bm3, "0: %p, 2: %p, 3: %p\n", bm, bm2, bm3);
todo_wine
    ok(bm != curObj2, "0: %p, curObj2 %p\n", bm, curObj2);
    ok(old2 == 0, "old2 %p\n", old2);

    test_mono_1x1_bmp(bm);
    test_mono_1x1_bmp(bm1);
    test_mono_1x1_bmp(bm2);
    test_mono_1x1_bmp(bm3);
    test_mono_1x1_bmp(bm4);
    test_mono_1x1_bmp(bm5);
    test_mono_1x1_bmp(old1);
    test_mono_1x1_bmp(curObj1);

    DeleteObject(bm);
    DeleteObject(bm1);
    DeleteObject(bm2);
    DeleteObject(bm3);
    DeleteObject(bm4);
    DeleteObject(bm5);

    DeleteDC(hdc);
    ReleaseDC(0, screenDC);

    /* show that Windows ignores the provided bm.bmWidthBytes */
    bmp.bmType = 0;
    bmp.bmWidth = 1;
    bmp.bmHeight = 1;
    bmp.bmWidthBytes = 28;
    bmp.bmPlanes = 1;
    bmp.bmBitsPixel = 1;
    bmp.bmBits = NULL;
    bm = CreateBitmapIndirect(&bmp);
    ok(bm != 0, "CreateBitmapIndirect error %u\n", GetLastError());
    test_mono_1x1_bmp(bm);
    DeleteObject(bm);

    /* Test how the bmBitsPixel field is treated */
    for(i = 1; i <= 33; i++) {
        bmp.bmType = 0;
        bmp.bmWidth = 1;
        bmp.bmHeight = 1;
        bmp.bmWidthBytes = 28;
        bmp.bmPlanes = 1;
        bmp.bmBitsPixel = i;
        bmp.bmBits = NULL;
        SetLastError(0xdeadbeef);
        bm = CreateBitmapIndirect(&bmp);
        if(i > 32) {
            DWORD error = GetLastError();
            ok(bm == 0, "CreateBitmapIndirect for %d bpp succeeded\n", i);
            ok(error == ERROR_INVALID_PARAMETER, "Got error %d, expected ERROR_INVALID_PARAMETER\n", error);
            DeleteObject(bm);
            continue;
        }
        ok(bm != 0, "CreateBitmapIndirect error %u\n", GetLastError());
        GetObjectW(bm, sizeof(bmp), &bmp);
        if(i == 1) {
            expect = 1;
        } else if(i <= 4) {
            expect = 4;
        } else if(i <= 8) {
            expect = 8;
        } else if(i <= 16) {
            expect = 16;
        } else if(i <= 24) {
            expect = 24;
        } else if(i <= 32) {
            expect = 32;
        }
        ok(bmp.bmBitsPixel == expect, "CreateBitmapIndirect for a %d bpp bitmap created a %d bpp bitmap, expected %d\n",
           i, bmp.bmBitsPixel, expect);
        DeleteObject(bm);
    }
}

Referenced by START_TEST().

test_createdibitmap()

static void test_createdibitmap ( void  )

static

Definition at line 128 of file bitmap.c.

{
    HDC hdc, hdcmem;
    BITMAPINFOHEADER bmih;
    BITMAPINFO bm;
    HBITMAP hbm, hbm_colour, hbm_old;
    INT screen_depth;
    DWORD pixel;

    hdc = GetDC(0);
    screen_depth = GetDeviceCaps(hdc, BITSPIXEL);
    memset(&bmih, 0, sizeof(bmih));
    bmih.biSize = sizeof(bmih);
    bmih.biWidth = 10;
    bmih.biHeight = 10;
    bmih.biPlanes = 1;
    bmih.biBitCount = 32;
    bmih.biCompression = BI_RGB;

    hbm = CreateDIBitmap(hdc, NULL, CBM_INIT, NULL, NULL, 0);
    ok(hbm == NULL, "CreateDIBitmap should fail\n");
    hbm = CreateDIBitmap(hdc, NULL, 0, NULL, NULL, 0);
    ok(hbm == NULL, "CreateDIBitmap should fail\n");

    /* First create an un-initialised bitmap.  The depth of the bitmap
       should match that of the hdc and not that supplied in bmih.
    */

    /* First try 32 bits */
    hbm = CreateDIBitmap(hdc, &bmih, 0, NULL, NULL, 0);
    ok(hbm != NULL, "CreateDIBitmap failed\n");
    test_bitmap_info(hbm, screen_depth, &bmih);
    DeleteObject(hbm);
    
    /* Then 16 */
    bmih.biBitCount = 16;
    hbm = CreateDIBitmap(hdc, &bmih, 0, NULL, NULL, 0);
    ok(hbm != NULL, "CreateDIBitmap failed\n");
    test_bitmap_info(hbm, screen_depth, &bmih);
    DeleteObject(hbm);

    /* Then 1 */
    bmih.biBitCount = 1;
    hbm = CreateDIBitmap(hdc, &bmih, 0, NULL, NULL, 0);
    ok(hbm != NULL, "CreateDIBitmap failed\n");
    test_bitmap_info(hbm, screen_depth, &bmih);
    DeleteObject(hbm);

    /* Now with a monochrome dc we expect a monochrome bitmap */
    hdcmem = CreateCompatibleDC(hdc);

    /* First try 32 bits */
    bmih.biBitCount = 32;
    hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
    ok(hbm != NULL, "CreateDIBitmap failed\n");
    test_bitmap_info(hbm, 1, &bmih);
    DeleteObject(hbm);
    
    /* Then 16 */
    bmih.biBitCount = 16;
    hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
    ok(hbm != NULL, "CreateDIBitmap failed\n");
    test_bitmap_info(hbm, 1, &bmih);
    DeleteObject(hbm);
    
    /* Then 1 */
    bmih.biBitCount = 1;
    hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
    ok(hbm != NULL, "CreateDIBitmap failed\n");
    test_bitmap_info(hbm, 1, &bmih);
    DeleteObject(hbm);

    /* Now select a polychrome bitmap into the dc and we expect
       screen_depth bitmaps again */
    hbm_colour = CreateCompatibleBitmap(hdc, bmih.biWidth, bmih.biHeight);
    test_bitmap_info(hbm_colour, screen_depth, &bmih);
    hbm_old = SelectObject(hdcmem, hbm_colour);

    /* First try 32 bits */
    bmih.biBitCount = 32;
    hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
    ok(hbm != NULL, "CreateDIBitmap failed\n");
    test_bitmap_info(hbm, screen_depth, &bmih);
    DeleteObject(hbm);
    
    /* Then 16 */
    bmih.biBitCount = 16;
    hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
    ok(hbm != NULL, "CreateDIBitmap failed\n");
    test_bitmap_info(hbm, screen_depth, &bmih);
    DeleteObject(hbm);
    
    /* Then 1 */
    bmih.biBitCount = 1;
    hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
    ok(hbm != NULL, "CreateDIBitmap failed\n");
    test_bitmap_info(hbm, screen_depth, &bmih);
    DeleteObject(hbm);

    SelectObject(hdcmem, hbm_old);
    DeleteObject(hbm_colour);
    DeleteDC(hdcmem);

    bmih.biBitCount = 32;
    hbm = CreateDIBitmap(0, &bmih, 0, NULL, NULL, 0);
    ok(hbm != NULL, "CreateDIBitmap failed\n");
    test_bitmap_info(hbm, 1, &bmih);
    DeleteObject(hbm);

    /* Test how formats are converted */
    pixel = 0xffffffff;
    bmih.biBitCount = 1;
    bmih.biWidth = 1;
    bmih.biHeight = 1;

    memset(&bm, 0, sizeof(bm));
    bm.bmiHeader.biSize = sizeof(bm.bmiHeader);
    bm.bmiHeader.biWidth = 1;
    bm.bmiHeader.biHeight = 1;
    bm.bmiHeader.biPlanes = 1;
    bm.bmiHeader.biBitCount= 24;
    bm.bmiHeader.biCompression= BI_RGB;
    bm.bmiHeader.biSizeImage = 0;
    hbm = CreateDIBitmap(hdc, &bmih, CBM_INIT, &pixel, &bm, DIB_RGB_COLORS);
    ok(hbm != NULL, "CreateDIBitmap failed\n");

    pixel = 0xdeadbeef;
    bm.bmiHeader.biBitCount= 32;
    GetDIBits(hdc, hbm, 0, 1, &pixel, &bm, DIB_RGB_COLORS);
    ok(pixel == 0x00ffffff, "Reading a 32 bit pixel from a DDB returned %08x\n", pixel);
    DeleteObject(hbm);

    ReleaseDC(0, hdc);
}

Referenced by START_TEST().

test_D3DKMTCreateDCFromMemory()

static void test_D3DKMTCreateDCFromMemory ( void  )

static

Definition at line 5667 of file bitmap.c.

{
    D3DKMT_DESTROYDCFROMMEMORY destroy_desc;
    D3DKMT_CREATEDCFROMMEMORY create_desc;
    unsigned int width_bytes;
    unsigned int i, x, y, z;
    DWORD expected, colour;
    BYTE data[12][48];
    NTSTATUS status;
    HGDIOBJ *bitmap;
    DIBSECTION dib;
    BOOL fail, ret;
    DWORD type, pixel;
    int size;
    HDC bmp_dc;
    HBITMAP bmp;

    static const struct
    {
        const char *name;
        D3DDDIFORMAT format;
        unsigned int bit_count;
        DWORD mask_r, mask_g, mask_b;
        NTSTATUS status;
    }
    test_data[] =
    {
        { "R8G8B8",      D3DDDIFMT_R8G8B8,      24, 0x00000000, 0x00000000, 0x00000000, STATUS_SUCCESS },
        { "A8R8G8B8",    D3DDDIFMT_A8R8G8B8,    32, 0x00000000, 0x00000000, 0x00000000, STATUS_SUCCESS },
        { "X8R8G8B8",    D3DDDIFMT_X8R8G8B8,    32, 0x00000000, 0x00000000, 0x00000000, STATUS_SUCCESS },
        { "R5G6B5",      D3DDDIFMT_R5G6B5,      16, 0x0000f800, 0x000007e0, 0x0000001f, STATUS_SUCCESS },
        { "X1R5G5B5",    D3DDDIFMT_X1R5G5B5,    16, 0x00007c00, 0x000003e0, 0x0000001f, STATUS_SUCCESS },
        { "A1R5G5B5",    D3DDDIFMT_A1R5G5B5,    16, 0x00007c00, 0x000003e0, 0x0000001f, STATUS_SUCCESS },
        { "R3G3B2",      D3DDDIFMT_R3G3B2,      8,  0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
        { "A2B10G10R10", D3DDDIFMT_A2B10G10R10, 32, 0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
        { "A8B8G8R8",    D3DDDIFMT_A8B8G8R8,    32, 0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
        { "X8B8G8R8",    D3DDDIFMT_A8B8G8R8,    32, 0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
        { "A2R10G10B10", D3DDDIFMT_A2R10G10B10, 32, 0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
        { "P8",          D3DDDIFMT_P8,          8,  0x00000000, 0x00000000, 0x00000000, STATUS_SUCCESS },
        { "L8",          D3DDDIFMT_L8,          8,  0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
        { "A8L8",        D3DDDIFMT_A8L8,        16, 0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
        { "V8U8",        D3DDDIFMT_V8U8,        16, 0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
        { "Q8W8V8U8",    D3DDDIFMT_Q8W8V8U8,    32, 0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
        { "DXT1",        D3DDDIFMT_DXT1,        4,  0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
        { "DXT2",        D3DDDIFMT_DXT2,        8,  0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
        { "DXT3",        D3DDDIFMT_DXT3,        8,  0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
        { "DXT4",        D3DDDIFMT_DXT4,        8,  0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
        { "DXT5",        D3DDDIFMT_DXT5,        8,  0x00000000, 0x00000000, 0x00000000, STATUS_INVALID_PARAMETER },
    };

    if (!pD3DKMTCreateDCFromMemory)
    {
        win_skip("D3DKMTCreateDCFromMemory() is not implemented.\n");
        return;
    }

    status = pD3DKMTCreateDCFromMemory( NULL );
    ok(status == STATUS_INVALID_PARAMETER, "Got unexpected status %#x.\n", status);

    for (i = 0; i < sizeof(test_data) / sizeof(*test_data); ++i)
    {
        memset( data, 0xaa, sizeof(data) );

        create_desc.pMemory = data;
        create_desc.Format = test_data[i].format;
        create_desc.Width = 9;
        create_desc.Height = 7;
        create_desc.Pitch = sizeof(*data);
        create_desc.hDeviceDc = NULL;
        create_desc.pColorTable = NULL;
        create_desc.hDc = (void *)0x010baade;
        create_desc.hBitmap = (void *)0x020baade;

        status = pD3DKMTCreateDCFromMemory( &create_desc );
        ok(status == STATUS_INVALID_PARAMETER, "%s: Got unexpected status %#x.\n",
           test_data[i].name, status);

        create_desc.hDeviceDc = CreateCompatibleDC( NULL );
        create_desc.pMemory = NULL;
        status = pD3DKMTCreateDCFromMemory( &create_desc );
        ok(status == STATUS_INVALID_PARAMETER, "%s: Got unexpected status %#x.\n",
           test_data[i].name, status);

        create_desc.pMemory = data;
        create_desc.Height = 0;
        status = pD3DKMTCreateDCFromMemory( &create_desc );
        ok(status == STATUS_INVALID_PARAMETER, "%s: Got unexpected status %#x.\n",
           test_data[i].name, status);
        ok(create_desc.hDc == (void *)0x010baade, "%s: Got unexpected dc %p.\n",
           test_data[i].name, create_desc.hDc);
        ok(create_desc.hBitmap == (void *)0x020baade, "%s: Got unexpected bitmap %p.\n",
           test_data[i].name, create_desc.hBitmap);

        create_desc.Height = 7;
        create_desc.Width = 0;
        status = pD3DKMTCreateDCFromMemory( &create_desc );
        ok(status == test_data[i].status, "%s: Got unexpected status %#x, expected %#x.\n",
           test_data[i].name, status, test_data[i].status);
        if (status == STATUS_SUCCESS)
        {
            destroy_desc.hDc = create_desc.hDc;
            destroy_desc.hBitmap = create_desc.hBitmap;
            status = pD3DKMTDestroyDCFromMemory( &destroy_desc );
            ok(status == STATUS_SUCCESS, "%s: Got unexpected status %#x.\n", test_data[i].name, status);
            create_desc.hDc = (void *)0x010baade;
            create_desc.hBitmap = (void *)0x020baade;
        }

        create_desc.Pitch = 0;
        status = pD3DKMTCreateDCFromMemory( &create_desc );
        ok(status == STATUS_INVALID_PARAMETER, "%s: Got unexpected status %#x.\n",
           test_data[i].name, status);
        ok(create_desc.hDc == (void *)0x010baade, "%s: Got unexpected dc %p.\n",
           test_data[i].name, create_desc.hDc);
        ok(create_desc.hBitmap == (void *)0x020baade, "%s: Got unexpected bitmap %p.\n",
           test_data[i].name, create_desc.hBitmap);

        create_desc.Width = 9;
        create_desc.Pitch = sizeof(*data);
        status = pD3DKMTCreateDCFromMemory( &create_desc );
        ok(status == test_data[i].status, "%s: Got unexpected status %#x, expected %#x.\n",
           test_data[i].name, status, test_data[i].status);
        if (status == STATUS_SUCCESS)
        {
            ok(!!create_desc.hDc, "%s: Got unexpected dc %p.\n",
               test_data[i].name, create_desc.hDc);
            ok(!!create_desc.hBitmap, "%s: Got unexpected bitmap %p.\n",
               test_data[i].name, create_desc.hBitmap);
        }
        else
        {
            ok(create_desc.hDc == (void *)0x010baade, "%s: Got unexpected dc %p.\n",
               test_data[i].name, create_desc.hDc);
            ok(create_desc.hBitmap == (void *)0x020baade, "%s: Got unexpected bitmap %p.\n",
               test_data[i].name, create_desc.hBitmap);
            continue;
        }

        type = GetObjectType( create_desc.hDc );
        ok(type == OBJ_MEMDC, "%s: Got unexpected object type %#x.\n", test_data[i].name, type);
        type = GetObjectType( create_desc.hBitmap );
        ok(type == OBJ_BITMAP, "%s: Got unexpected object type %#x.\n", test_data[i].name, type);
        bitmap = GetCurrentObject( create_desc.hDc, OBJ_BITMAP );
        ok(bitmap == create_desc.hBitmap, "%s: Got unexpected bitmap %p, expected %p.\n",
           test_data[i].name, bitmap, create_desc.hBitmap);

        size = GetObjectA( bitmap, sizeof(dib), &dib );
        ok(size == sizeof(dib), "%s: Got unexpected size %d.\n", test_data[i].name, size);
        ok(!dib.dsBm.bmType, "%s: Got unexpected type %#x.\n",
           test_data[i].name, dib.dsBm.bmType);
        ok(dib.dsBm.bmWidth == create_desc.Width, "%s: Got unexpected width %d.\n",
           test_data[i].name, dib.dsBm.bmWidth);
        ok(dib.dsBm.bmHeight == create_desc.Height, "%s: Got unexpected height %d.\n",
           test_data[i].name, dib.dsBm.bmHeight);
        width_bytes = get_dib_stride( create_desc.Width, test_data[i].bit_count );
        ok(dib.dsBm.bmWidthBytes == width_bytes, "%s: Got unexpected width bytes %d.\n",
           test_data[i].name, dib.dsBm.bmWidthBytes);
        ok(dib.dsBm.bmPlanes == 1, "%s: Got unexpected plane count %d.\n",
           test_data[i].name, dib.dsBm.bmPlanes);
        ok(dib.dsBm.bmBitsPixel == test_data[i].bit_count, "%s: Got unexpected bit count %d.\n",
           test_data[i].name, dib.dsBm.bmBitsPixel);
        ok(dib.dsBm.bmBits == create_desc.pMemory, "%s: Got unexpected bits %p, expected %p.\n",
           test_data[i].name, dib.dsBm.bmBits, create_desc.pMemory);

        ok(dib.dsBmih.biSize == sizeof(dib.dsBmih), "%s: Got unexpected size %u.\n",
           test_data[i].name, dib.dsBmih.biSize);
        ok(dib.dsBmih.biWidth == create_desc.Width, "%s: Got unexpected width %d.\n",
           test_data[i].name, dib.dsBmih.biHeight);
        ok(dib.dsBmih.biHeight == create_desc.Height, "%s: Got unexpected height %d.\n",
           test_data[i].name, dib.dsBmih.biHeight);
        ok(dib.dsBmih.biPlanes == 1, "%s: Got unexpected plane count %u.\n",
           test_data[i].name, dib.dsBmih.biPlanes);
        ok(dib.dsBmih.biBitCount == test_data[i].bit_count, "%s: Got unexpected bit count %u.\n",
           test_data[i].name, dib.dsBmih.biBitCount);
        ok(dib.dsBmih.biCompression == (test_data[i].bit_count == 16 ? BI_BITFIELDS : BI_RGB),
           "%s: Got unexpected compression %#x.\n",
           test_data[i].name, dib.dsBmih.biCompression);
        ok(!dib.dsBmih.biSizeImage, "%s: Got unexpected image size %u.\n",
           test_data[i].name, dib.dsBmih.biSizeImage);
        ok(!dib.dsBmih.biXPelsPerMeter, "%s: Got unexpected horizontal resolution %d.\n",
           test_data[i].name, dib.dsBmih.biXPelsPerMeter);
        ok(!dib.dsBmih.biYPelsPerMeter, "%s: Got unexpected vertical resolution %d.\n",
           test_data[i].name, dib.dsBmih.biYPelsPerMeter);
        if (test_data[i].format == D3DDDIFMT_P8)
        {
            ok(dib.dsBmih.biClrUsed == 256, "%s: Got unexpected used colour count %u.\n",
               test_data[i].name, dib.dsBmih.biClrUsed);
            ok(dib.dsBmih.biClrImportant == 256, "%s: Got unexpected important colour count %u.\n",
               test_data[i].name, dib.dsBmih.biClrImportant);
        }
        else
        {
            ok(!dib.dsBmih.biClrUsed, "%s: Got unexpected used colour count %u.\n",
               test_data[i].name, dib.dsBmih.biClrUsed);
            ok(!dib.dsBmih.biClrImportant, "%s: Got unexpected important colour count %u.\n",
               test_data[i].name, dib.dsBmih.biClrImportant);
        }

        ok(dib.dsBitfields[0] == test_data[i].mask_r && dib.dsBitfields[1] == test_data[i].mask_g
           && dib.dsBitfields[2] == test_data[i].mask_b,
           "%s: Got unexpected colour masks 0x%08x 0x%08x 0x%08x.\n",
           test_data[i].name, dib.dsBitfields[0], dib.dsBitfields[1], dib.dsBitfields[2]);
        ok(!dib.dshSection, "%s: Got unexpected section %p.\n", test_data[i].name, dib.dshSection);
        ok(!dib.dsOffset, "%s: Got unexpected offset %u.\n", test_data[i].name, dib.dsOffset);

        ret = BitBlt( create_desc.hDc, 0, 0, 4, 10, NULL, 0, 0, BLACKNESS );
        ok(ret, "Failed to blit.\n");
        ret = BitBlt( create_desc.hDc, 1, 1, 2, 2, NULL, 0, 0, WHITENESS );
        ok(ret, "Failed to blit.\n");

        /* Also test blitting to a regular bitmap */
        bmp_dc = CreateCompatibleDC( create_desc.hDeviceDc );
        ok(bmp_dc != NULL, "failed to create DC\n");
        bmp = CreateCompatibleBitmap( bmp_dc, create_desc.Width, create_desc.Height );
        ok(bmp != NULL, "failed to create bmp\n");
        bmp = SelectObject( bmp_dc, bmp );
        ret = BitBlt( bmp_dc, 0, 0, create_desc.Width, create_desc.Height, create_desc.hDc, 0, 0, SRCCOPY );
        ok(ret, "Failed to blit.\n");

        destroy_desc.hDc = create_desc.hDc;
        destroy_desc.hBitmap = create_desc.hBitmap;

        status = pD3DKMTDestroyDCFromMemory( NULL );
        ok(status == STATUS_INVALID_PARAMETER, "%s: Got unexpected status %#x.\n", test_data[i].name, status);
        status = pD3DKMTDestroyDCFromMemory( &destroy_desc );
        ok(status == STATUS_SUCCESS, "%s: Got unexpected status %#x.\n", test_data[i].name, status);
        status = pD3DKMTDestroyDCFromMemory( &destroy_desc );
        ok(status == STATUS_INVALID_PARAMETER, "%s: Got unexpected status %#x.\n", test_data[i].name, status);

        ret = DeleteDC( create_desc.hDeviceDc );
        ok(ret, "Failed to delete dc.\n");

        for (y = 0, fail = FALSE; y < 12 && !fail; ++y)
        {
            for (x = 0; x < sizeof(*data) / (test_data[i].bit_count / 8) && !fail; ++x)
            {
                for (z = 0, colour = 0; z < test_data[i].bit_count / 8; ++z)
                {
                    colour = colour << 8 | data[y][x * (test_data[i].bit_count / 8) + z];
                }

                if ((x == 1 || x == 2) && (y == 1 || y == 2))
                    expected = 0xffffffff >> (32 - test_data[i].bit_count);
                else if (x < 4 && y < 7)
                    expected = 0x00000000;
                else
                    expected = 0xaaaaaaaa >> (32 - test_data[i].bit_count);
                ok(colour == expected, "%s: Got unexpected colour 0x%08x at %u, %u, expected 0x%08x.\n",
                   test_data[i].name, colour, x, y, expected);
                if (colour != expected)
                    fail = TRUE;

                /* 'Xn' or 'An' formats don't successfully blit to the regular bmp */
                if (test_data[i].format == D3DDDIFMT_R8G8B8 || test_data[i].format == D3DDDIFMT_R5G6B5)
                {
                    pixel = GetPixel( bmp_dc, x, y );
                    if ((x == 1 || x == 2) && (y == 1 || y == 2))
                        expected = 0x00ffffff;
                    else if (x < create_desc.Width && y < create_desc.Height)
                        expected = 0x00000000;
                    else
                        expected = CLR_INVALID;
                    ok(pixel == expected, "%s: got 0x%08x at %u, %u, expect 0x%08x\n", test_data[i].name,
                       pixel, x, y, expected);
                }
            }
        }

        DeleteObject( SelectObject( bmp_dc, bmp ) );
        DeleteDC( bmp_dc );
    }
}

Referenced by START_TEST().

test_dib_bits_access()

static void test_dib_bits_access ( HBITMAP  hdib, void *  bits  )

static

Definition at line 376 of file bitmap.c.

{
    MEMORY_BASIC_INFORMATION info;
    char bmibuf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)];
    DWORD data[256];
    BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
    HDC hdc;
    char filename[MAX_PATH];
    HANDLE file;
    DWORD written;
    INT ret;

    ok(VirtualQuery(bits, &info, sizeof(info)) == sizeof(info),
        "VirtualQuery failed\n");
    ok(info.BaseAddress == bits, "%p != %p\n", info.BaseAddress, bits);
    ok(info.AllocationBase == bits, "%p != %p\n", info.AllocationBase, bits);
    ok(info.AllocationProtect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.AllocationProtect);
    ok(info.State == MEM_COMMIT, "%x != MEM_COMMIT\n", info.State);
    ok(info.Protect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.Protect);
    ok(info.Type == MEM_PRIVATE, "%x != MEM_PRIVATE\n", info.Type);

    memset( pbmi, 0, sizeof(bmibuf) );
    memset( data, 0xcc, sizeof(data) );
    pbmi->bmiHeader.biSize = sizeof(pbmi->bmiHeader);
    pbmi->bmiHeader.biHeight = 16;
    pbmi->bmiHeader.biWidth = 16;
    pbmi->bmiHeader.biBitCount = 32;
    pbmi->bmiHeader.biPlanes = 1;
    pbmi->bmiHeader.biCompression = BI_RGB;

    hdc = GetDC(0);

    ret = SetDIBits( hdc, hdib, 0, 16, data, pbmi, DIB_RGB_COLORS );
    ok(ret == 16, "SetDIBits failed: expected 16 got %d\n", ret);

    ReleaseDC(0, hdc);

    ok(VirtualQuery(bits, &info, sizeof(info)) == sizeof(info),
        "VirtualQuery failed\n");
    ok(info.BaseAddress == bits, "%p != %p\n", info.BaseAddress, bits);
    ok(info.AllocationBase == bits, "%p != %p\n", info.AllocationBase, bits);
    ok(info.AllocationProtect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.AllocationProtect);
    ok(info.State == MEM_COMMIT, "%x != MEM_COMMIT\n", info.State);
    ok(info.Type == MEM_PRIVATE, "%x != MEM_PRIVATE\n", info.Type);
    ok(info.Protect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.Protect);

    /* try writing protected bits to a file */

    GetTempFileNameA( ".", "dib", 0, filename );
    file = CreateFileA( filename, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
                        CREATE_ALWAYS, 0, 0 );
    ok( file != INVALID_HANDLE_VALUE, "failed to open %s error %u\n", filename, GetLastError() );
    ret = WriteFile( file, bits, 8192, &written, NULL );
    ok( ret, "WriteFile failed error %u\n", GetLastError() );
    if (ret) ok( written == 8192, "only wrote %u bytes\n", written );
    CloseHandle( file );
    DeleteFileA( filename );
}

Referenced by test_dibsections().

test_dib_formats()

static void test_dib_formats ( void  )

static

Definition at line 916 of file bitmap.c.

{
    BITMAPINFO *bi;
    char data[256];
    void *bits;
    int planes, bpp, compr, format;
    HBITMAP hdib, hbmp;
    HDC hdc, memdc;
    UINT ret;
    BOOL format_ok, expect_ok;

    bi = HeapAlloc( GetProcessHeap(), 0, FIELD_OFFSET( BITMAPINFO, bmiColors[256] ) );
    hdc = GetDC( 0 );
    memdc = CreateCompatibleDC( 0 );
    hbmp = CreateCompatibleBitmap( hdc, 10, 10 );

    memset( data, 0xaa, sizeof(data) );

    if (!winetest_interactive)
        skip("ROSTESTS-152: Skipping loop in test_dib_formats because it's too big and causes too many failures\n");
    else
    for (bpp = 0; bpp <= 64; bpp++)
    {
        for (planes = 0; planes <= 64; planes++)
        {
            for (compr = 0; compr < 8; compr++)
            {
                for (format = DIB_RGB_COLORS; format <= DIB_PAL_COLORS; format++)
                {
                    switch (bpp)
                    {
                    case 1:
                    case 4:
                    case 8:
                    case 24: expect_ok = (compr == BI_RGB); break;
                    case 16:
                    case 32: expect_ok = (compr == BI_RGB || compr == BI_BITFIELDS); break;
                    default: expect_ok = FALSE; break;
                    }

                    memset( bi, 0, sizeof(bi->bmiHeader) );
                    bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
                    bi->bmiHeader.biWidth = 2;
                    bi->bmiHeader.biHeight = 2;
                    bi->bmiHeader.biPlanes = planes;
                    bi->bmiHeader.biBitCount = bpp;
                    bi->bmiHeader.biCompression = compr;
                    bi->bmiHeader.biSizeImage = 0;
                    memset( bi->bmiColors, 0xaa, sizeof(RGBQUAD) * 256 );
                    ret = GetDIBits(hdc, hbmp, 0, 0, data, bi, format);
                    if (expect_ok || (!bpp && compr != BI_JPEG && compr != BI_PNG) ||
                        (bpp == 4 && compr == BI_RLE4) || (bpp == 8 && compr == BI_RLE8))
                        ok( ret, "GetDIBits failed for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    else
                        ok( !ret || broken(!bpp && (compr == BI_JPEG || compr == BI_PNG)), /* nt4 */
                            "GetDIBits succeeded for %u/%u/%u/%u\n", bpp, planes, compr, format );

                    /* all functions check planes except GetDIBits with 0 lines */
                    format_ok = expect_ok;
                    if (!planes) expect_ok = FALSE;
                    memset( bi, 0, sizeof(bi->bmiHeader) );
                    bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
                    bi->bmiHeader.biWidth = 2;
                    bi->bmiHeader.biHeight = 2;
                    bi->bmiHeader.biPlanes = planes;
                    bi->bmiHeader.biBitCount = bpp;
                    bi->bmiHeader.biCompression = compr;
                    bi->bmiHeader.biSizeImage = 0;
                    memset( bi->bmiColors, 0xaa, sizeof(RGBQUAD) * 256 );

                    hdib = CreateDIBSection(hdc, bi, format, &bits, NULL, 0);
                    if (expect_ok && (planes == 1 || planes * bpp <= 16) &&
                        (compr != BI_BITFIELDS || format != DIB_PAL_COLORS))
                        ok( hdib != NULL, "CreateDIBSection failed for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    else
                        ok( hdib == NULL, "CreateDIBSection succeeded for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    if (hdib) DeleteObject( hdib );

                    hdib = CreateDIBitmap( hdc, &bi->bmiHeader, 0, data, bi, format );
                    /* no sanity checks in CreateDIBitmap except compression */
                    if (compr == BI_JPEG || compr == BI_PNG)
                        ok( hdib == NULL || broken(hdib != NULL), /* nt4 */
                            "CreateDIBitmap succeeded for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    else
                        ok( hdib != NULL, "CreateDIBitmap failed for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    if (hdib) DeleteObject( hdib );

                    /* RLE needs a size */
                    bi->bmiHeader.biSizeImage = 0;
                    ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, format);
                    if (expect_ok)
                        ok( ret, "SetDIBits failed for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    else
                        ok( !ret ||
                            broken((bpp == 4 && compr == BI_RLE4) || (bpp == 8 && compr == BI_RLE8)), /* nt4 */
                            "SetDIBits succeeded for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    ret = SetDIBitsToDevice( memdc, 0, 0, 1, 1, 0, 0, 0, 1, data, bi, format );
                    if (expect_ok)
                        ok( ret, "SetDIBitsToDevice failed for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    else
                        ok( !ret ||
                            broken((bpp == 4 && compr == BI_RLE4) || (bpp == 8 && compr == BI_RLE8)), /* nt4 */
                            "SetDIBitsToDevice succeeded for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    ret = StretchDIBits( memdc, 0, 0, 1, 1, 0, 0, 1, 1, data, bi, format, SRCCOPY );
                    if (expect_ok)
                        ok( ret, "StretchDIBits failed for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    else
                        ok( !ret ||
                            broken((bpp == 4 && compr == BI_RLE4) || (bpp == 8 && compr == BI_RLE8)), /* nt4 */
                            "StretchDIBits succeeded for %u/%u/%u/%u\n", bpp, planes, compr, format );

                    ret = GetDIBits(hdc, hbmp, 0, 2, data, bi, format);
                    if (expect_ok)
                        ok( ret, "GetDIBits failed for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    else
                        ok( !ret, "GetDIBits succeeded for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    ok( bi->bmiHeader.biBitCount == bpp, "GetDIBits modified bpp %u/%u\n",
                        bpp, bi->bmiHeader.biBitCount );

                    bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
                    bi->bmiHeader.biWidth = 2;
                    bi->bmiHeader.biHeight = 2;
                    bi->bmiHeader.biPlanes = planes;
                    bi->bmiHeader.biBitCount = bpp;
                    bi->bmiHeader.biCompression = compr;
                    bi->bmiHeader.biSizeImage = 1;
                    memset( bi->bmiColors, 0xaa, sizeof(RGBQUAD) * 256 );
                    /* RLE allowed with valid biSizeImage */
                    if ((bpp == 4 && compr == BI_RLE4) || (bpp == 8 && compr == BI_RLE8)) expect_ok = TRUE;

                    ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, format);
                    if (expect_ok)
                        ok( ret, "SetDIBits failed for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    else
                        ok( !ret, "SetDIBits succeeded for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    ret = SetDIBitsToDevice( memdc, 0, 0, 1, 1, 0, 0, 0, 1, data, bi, format );
                    if (expect_ok)
                        ok( ret, "SetDIBitsToDevice failed for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    else
                        ok( !ret, "SetDIBitsToDevice succeeded for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    ret = StretchDIBits( memdc, 0, 0, 1, 1, 0, 0, 1, 1, data, bi, format, SRCCOPY );
                    if (expect_ok)
                        ok( ret, "StretchDIBits failed for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    else
                        ok( !ret, "StretchDIBits succeeded for %u/%u/%u/%u\n", bpp, planes, compr, format );

                    bi->bmiHeader.biSizeImage = 0;
                    ret = GetDIBits(hdc, hbmp, 0, 2, NULL, bi, format);
                    if (expect_ok || !bpp)
                        ok( ret, "GetDIBits failed for %u/%u/%u/%u\n", bpp, planes, compr, format );
                    else
                        ok( !ret || broken(format_ok && !planes),  /* nt4 */
                            "GetDIBits succeeded for %u/%u/%u/%u\n", bpp, planes, compr, format );
                }
            }
        }
    }

    memset( bi, 0, sizeof(bi->bmiHeader) );
    bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
    bi->bmiHeader.biWidth = 2;
    bi->bmiHeader.biHeight = 2;
    bi->bmiHeader.biPlanes = 1;
    bi->bmiHeader.biBitCount = 16;
    bi->bmiHeader.biCompression = BI_BITFIELDS;
    bi->bmiHeader.biSizeImage = 0;
    *(DWORD *)&bi->bmiColors[0] = 0;
    *(DWORD *)&bi->bmiColors[1] = 0;
    *(DWORD *)&bi->bmiColors[2] = 0;

    hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
    ok( hdib == NULL, "CreateDIBSection succeeded with null bitfields\n" );
    ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, DIB_RGB_COLORS);
    ok( !ret, "SetDIBits succeeded with null bitfields\n" );
    /* other functions don't check */
    hdib = CreateDIBitmap( hdc, &bi->bmiHeader, 0, bits, bi, DIB_RGB_COLORS );
    ok( hdib != NULL, "CreateDIBitmap failed with null bitfields\n" );
    DeleteObject( hdib );
    ret = SetDIBitsToDevice( memdc, 0, 0, 1, 1, 0, 0, 0, 1, data, bi, DIB_RGB_COLORS );
    ok( ret, "SetDIBitsToDevice failed with null bitfields\n" );
    ret = StretchDIBits( memdc, 0, 0, 1, 1, 0, 0, 1, 1, data, bi, DIB_RGB_COLORS, SRCCOPY );
    ok( ret, "StretchDIBits failed with null bitfields\n" );
    ret = GetDIBits(hdc, hbmp, 0, 2, data, bi, DIB_RGB_COLORS);
    ok( ret, "GetDIBits failed with null bitfields\n" );
    bi->bmiHeader.biPlanes = 1;
    bi->bmiHeader.biBitCount = 16;
    bi->bmiHeader.biCompression = BI_BITFIELDS;
    bi->bmiHeader.biSizeImage = 0;
    *(DWORD *)&bi->bmiColors[0] = 0;
    *(DWORD *)&bi->bmiColors[1] = 0;
    *(DWORD *)&bi->bmiColors[2] = 0;
    ret = GetDIBits(hdc, hbmp, 0, 2, NULL, bi, DIB_RGB_COLORS);
    ok( ret, "GetDIBits failed with null bitfields\n" );

    /* all fields must be non-zero */
    *(DWORD *)&bi->bmiColors[0] = 3;
    *(DWORD *)&bi->bmiColors[1] = 0;
    *(DWORD *)&bi->bmiColors[2] = 7;
    hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
    ok( hdib == NULL, "CreateDIBSection succeeded with null bitfields\n" );
    ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, DIB_RGB_COLORS);
    ok( !ret, "SetDIBits succeeded with null bitfields\n" );

    /* garbage is ok though */
    *(DWORD *)&bi->bmiColors[0] = 0x55;
    *(DWORD *)&bi->bmiColors[1] = 0x44;
    *(DWORD *)&bi->bmiColors[2] = 0x33;
    hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
    ok( hdib != NULL, "CreateDIBSection failed with bad bitfields\n" );
    if (hdib) DeleteObject( hdib );
    ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, DIB_RGB_COLORS);
    ok( ret, "SetDIBits failed with bad bitfields\n" );

    bi->bmiHeader.biWidth = -2;
    bi->bmiHeader.biHeight = 2;
    bi->bmiHeader.biBitCount = 32;
    bi->bmiHeader.biCompression = BI_RGB;
    hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
    ok( hdib == NULL, "CreateDIBSection succeeded with negative width\n" );
    hdib = CreateDIBitmap( hdc, &bi->bmiHeader, 0, bits, bi, DIB_RGB_COLORS );
    ok( hdib == NULL, "CreateDIBitmap succeeded with negative width\n" );
    ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, DIB_RGB_COLORS);
    ok( !ret, "SetDIBits succeeded with negative width\n" );
    ret = SetDIBitsToDevice( memdc, 0, 0, 1, 1, 0, 0, 0, 1, data, bi, DIB_RGB_COLORS );
    ok( !ret, "SetDIBitsToDevice succeeded with negative width\n" );
    ret = StretchDIBits( memdc, 0, 0, 1, 1, 0, 0, 1, 1, data, bi, DIB_RGB_COLORS, SRCCOPY );
    ok( !ret, "StretchDIBits succeeded with negative width\n" );
    ret = GetDIBits(hdc, hbmp, 0, 2, data, bi, DIB_RGB_COLORS);
    ok( !ret, "GetDIBits succeeded with negative width\n" );
    bi->bmiHeader.biWidth = -2;
    bi->bmiHeader.biHeight = 2;
    bi->bmiHeader.biBitCount = 32;
    bi->bmiHeader.biCompression = BI_RGB;
    ret = GetDIBits(hdc, hbmp, 0, 2, NULL, bi, DIB_RGB_COLORS);
    ok( !ret || broken(ret), /* nt4 */ "GetDIBits succeeded with negative width\n" );

    bi->bmiHeader.biWidth = 0;
    bi->bmiHeader.biHeight = 2;
    bi->bmiHeader.biBitCount = 32;
    bi->bmiHeader.biCompression = BI_RGB;
    hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
    ok( hdib == NULL, "CreateDIBSection succeeded with zero width\n" );
    hdib = CreateDIBitmap( hdc, &bi->bmiHeader, 0, bits, bi, DIB_RGB_COLORS );
    ok( hdib != NULL, "CreateDIBitmap failed with zero width\n" );
    DeleteObject( hdib );
    ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, DIB_RGB_COLORS);
    ok( !ret || broken(ret), /* nt4 */ "SetDIBits succeeded with zero width\n" );
    ret = SetDIBitsToDevice( memdc, 0, 0, 1, 1, 0, 0, 0, 1, data, bi, DIB_RGB_COLORS );
    ok( !ret || broken(ret), /* nt4 */ "SetDIBitsToDevice succeeded with zero width\n" );
    ret = StretchDIBits( memdc, 0, 0, 1, 1, 0, 0, 1, 1, data, bi, DIB_RGB_COLORS, SRCCOPY );
    ok( !ret || broken(ret), /* nt4 */ "StretchDIBits succeeded with zero width\n" );
    ret = GetDIBits(hdc, hbmp, 0, 2, data, bi, DIB_RGB_COLORS);
    ok( !ret, "GetDIBits succeeded with zero width\n" );
    bi->bmiHeader.biWidth = 0;
    bi->bmiHeader.biHeight = 2;
    bi->bmiHeader.biBitCount = 32;
    bi->bmiHeader.biCompression = BI_RGB;
    ret = GetDIBits(hdc, hbmp, 0, 2, NULL, bi, DIB_RGB_COLORS);
    ok( !ret || broken(ret), /* nt4 */ "GetDIBits succeeded with zero width\n" );

    bi->bmiHeader.biWidth = 2;
    bi->bmiHeader.biHeight = 0;
    bi->bmiHeader.biBitCount = 32;
    bi->bmiHeader.biCompression = BI_RGB;
    hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
    ok( hdib == NULL, "CreateDIBSection succeeded with zero height\n" );
    hdib = CreateDIBitmap( hdc, &bi->bmiHeader, 0, bits, bi, DIB_RGB_COLORS );
    ok( hdib != NULL, "CreateDIBitmap failed with zero height\n" );
    DeleteObject( hdib );
    ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, DIB_RGB_COLORS);
    ok( !ret, "SetDIBits succeeded with zero height\n" );
    ret = SetDIBitsToDevice( memdc, 0, 0, 1, 1, 0, 0, 0, 1, data, bi, DIB_RGB_COLORS );
    ok( !ret, "SetDIBitsToDevice succeeded with zero height\n" );
    ret = StretchDIBits( memdc, 0, 0, 1, 1, 0, 0, 1, 1, data, bi, DIB_RGB_COLORS, SRCCOPY );
    ok( !ret, "StretchDIBits succeeded with zero height\n" );
    ret = GetDIBits(hdc, hbmp, 0, 2, data, bi, DIB_RGB_COLORS);
    ok( !ret || broken(ret), /* nt4 */ "GetDIBits succeeded with zero height\n" );
    bi->bmiHeader.biWidth = 2;
    bi->bmiHeader.biHeight = 0;
    bi->bmiHeader.biBitCount = 32;
    bi->bmiHeader.biCompression = BI_RGB;
    ret = GetDIBits(hdc, hbmp, 0, 2, NULL, bi, DIB_RGB_COLORS);
    ok( !ret || broken(ret), /* nt4 */ "GetDIBits succeeded with zero height\n" );

    /* some functions accept DIB_PAL_COLORS+1, but not beyond */

    bi->bmiHeader.biWidth = 2;
    bi->bmiHeader.biHeight = 2;
    bi->bmiHeader.biBitCount = 1;
    bi->bmiHeader.biCompression = BI_RGB;
    hdib = CreateDIBSection(hdc, bi, DIB_PAL_COLORS+1, &bits, NULL, 0);
    ok( hdib == NULL, "CreateDIBSection succeeded with DIB_PAL_COLORS+1\n" );
    hdib = CreateDIBitmap( hdc, &bi->bmiHeader, 0, bits, bi, DIB_PAL_COLORS+1 );
    ok( hdib != NULL, "CreateDIBitmap failed with DIB_PAL_COLORS+1\n" );
    DeleteObject( hdib );
    ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, DIB_PAL_COLORS+1);
    ok( !ret, "SetDIBits succeeded with DIB_PAL_COLORS+1\n" );
    ret = SetDIBitsToDevice( memdc, 0, 0, 1, 1, 0, 0, 0, 1, data, bi, DIB_PAL_COLORS+1 );
    ok( ret, "SetDIBitsToDevice failed with DIB_PAL_COLORS+1\n" );
    ret = StretchDIBits( memdc, 0, 0, 1, 1, 0, 0, 1, 1, data, bi, DIB_PAL_COLORS+1, SRCCOPY );
    ok( ret, "StretchDIBits failed with DIB_PAL_COLORS+1\n" );
    ret = GetDIBits(hdc, hbmp, 0, 2, data, bi, DIB_PAL_COLORS+1);
    ok( !ret, "GetDIBits succeeded with DIB_PAL_COLORS+1\n" );
    bi->bmiHeader.biWidth = 2;
    bi->bmiHeader.biHeight = 2;
    bi->bmiHeader.biBitCount = 1;
    bi->bmiHeader.biCompression = BI_RGB;
    ret = GetDIBits(hdc, hbmp, 0, 0, NULL, bi, DIB_PAL_COLORS+1);
    ok( !ret, "GetDIBits succeeded with DIB_PAL_COLORS+1\n" );

    bi->bmiHeader.biWidth = 2;
    bi->bmiHeader.biHeight = 2;
    bi->bmiHeader.biBitCount = 1;
    bi->bmiHeader.biCompression = BI_RGB;
    hdib = CreateDIBSection(hdc, bi, DIB_PAL_COLORS+2, &bits, NULL, 0);
    ok( hdib == NULL, "CreateDIBSection succeeded with DIB_PAL_COLORS+2\n" );
    hdib = CreateDIBitmap( hdc, &bi->bmiHeader, 0, bits, bi, DIB_PAL_COLORS+2 );
    ok( hdib == NULL, "CreateDIBitmap succeeded with DIB_PAL_COLORS+2\n" );
    DeleteObject( hdib );
    ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, DIB_PAL_COLORS+2);
    ok( !ret, "SetDIBits succeeded with DIB_PAL_COLORS+2\n" );
    ret = SetDIBitsToDevice( memdc, 0, 0, 1, 1, 0, 0, 0, 1, data, bi, DIB_PAL_COLORS+2 );
    ok( !ret, "SetDIBitsToDevice succeeded with DIB_PAL_COLORS+2\n" );
    ret = StretchDIBits( memdc, 0, 0, 1, 1, 0, 0, 1, 1, data, bi, DIB_PAL_COLORS+2, SRCCOPY );
    ok( !ret, "StretchDIBits succeeded with DIB_PAL_COLORS+2\n" );
    ret = GetDIBits(hdc, hbmp, 0, 2, data, bi, DIB_PAL_COLORS+2);
    ok( !ret, "GetDIBits succeeded with DIB_PAL_COLORS+2\n" );
    bi->bmiHeader.biWidth = 2;
    bi->bmiHeader.biHeight = 2;
    bi->bmiHeader.biBitCount = 1;
    bi->bmiHeader.biCompression = BI_RGB;
    ret = GetDIBits(hdc, hbmp, 0, 0, NULL, bi, DIB_PAL_COLORS+2);
    ok( !ret, "GetDIBits succeeded with DIB_PAL_COLORS+2\n" );

    bi->bmiHeader.biWidth = 0x4000;
    bi->bmiHeader.biHeight = 0x4000;
    bi->bmiHeader.biBitCount = 1;
    bi->bmiHeader.biCompression = BI_RGB;
    hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
    ok( hdib != NULL, "CreateDIBSection failed with large size\n" );
    DeleteObject( hdib );

    bi->bmiHeader.biWidth = 0x8001;
    bi->bmiHeader.biHeight = 0x8001;
    bi->bmiHeader.biBitCount = 32;
    bi->bmiHeader.biCompression = BI_RGB;
    hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
    ok( hdib == NULL, "CreateDIBSection succeeded with size overflow\n" );

    bi->bmiHeader.biWidth = 1;
    bi->bmiHeader.biHeight = 0x40000001;
    bi->bmiHeader.biBitCount = 32;
    bi->bmiHeader.biCompression = BI_RGB;
    hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
    ok( hdib == NULL, "CreateDIBSection succeeded with size overflow\n" );

    bi->bmiHeader.biWidth = 2;
    bi->bmiHeader.biHeight = 0x40000001;
    bi->bmiHeader.biBitCount = 16;
    bi->bmiHeader.biCompression = BI_RGB;
    hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
    ok( hdib == NULL, "CreateDIBSection succeeded with size overflow\n" );

    bi->bmiHeader.biWidth = 0x40000001;
    bi->bmiHeader.biHeight = 1;
    bi->bmiHeader.biBitCount = 32;
    bi->bmiHeader.biCompression = BI_RGB;
    hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
    ok( hdib == NULL, "CreateDIBSection succeeded with size overflow\n" );

    bi->bmiHeader.biWidth = 0x40000001;
    bi->bmiHeader.biHeight = 4;
    bi->bmiHeader.biBitCount = 8;
    bi->bmiHeader.biCompression = BI_RGB;
    hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, &bits, NULL, 0);
    ok( hdib == NULL, "CreateDIBSection succeeded with size overflow\n" );

    DeleteDC( memdc );
    DeleteObject( hbmp );
    ReleaseDC( 0, hdc );
    HeapFree( GetProcessHeap(), 0, bi );
}

Referenced by START_TEST().

test_dib_info()

static void test_dib_info ( HBITMAP  hbm, const void *  bits, const BITMAPINFOHEADER *  bmih  )

static

Definition at line 263 of file bitmap.c.

{
    BITMAP bm;
    BITMAP bma[2];
    DIBSECTION ds;
    DIBSECTION dsa[2];
    INT ret, bm_width_bytes, dib_width_bytes;
    BYTE *buf;

    ret = GetObjectW(hbm, sizeof(bm), &bm);
    ok(ret == sizeof(bm), "GetObject returned %d\n", ret);

    ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
    ok(bm.bmWidth == bmih->biWidth, "wrong bm.bmWidth %d\n", bm.bmWidth);
    ok(bm.bmHeight == abs(bmih->biHeight), "wrong bm.bmHeight %d\n", bm.bmHeight);
    dib_width_bytes = get_dib_stride(bm.bmWidth, bm.bmBitsPixel);
    bm_width_bytes = get_bitmap_stride(bm.bmWidth, bm.bmBitsPixel);
    if (bm.bmWidthBytes != dib_width_bytes) /* Win2k bug */
        ok(bm.bmWidthBytes == bm_width_bytes, "wrong bm.bmWidthBytes %d != %d\n", bm.bmWidthBytes, bm_width_bytes);
    else
        ok(bm.bmWidthBytes == dib_width_bytes, "wrong bm.bmWidthBytes %d != %d\n", bm.bmWidthBytes, dib_width_bytes);
    ok(bm.bmPlanes == bmih->biPlanes, "wrong bm.bmPlanes %d\n", bm.bmPlanes);
    ok(bm.bmBitsPixel == bmih->biBitCount, "bm.bmBitsPixel %d != %d\n", bm.bmBitsPixel, bmih->biBitCount);
    ok(bm.bmBits == bits, "wrong bm.bmBits %p != %p\n", bm.bmBits, bits);

    buf = HeapAlloc(GetProcessHeap(), 0, bm.bmWidthBytes * bm.bmHeight + 4096);

    /* GetBitmapBits returns not 32-bit aligned data */
    SetLastError(0xdeadbeef);
    ret = GetBitmapBits(hbm, 0, NULL);
    ok(ret == bm_width_bytes * bm.bmHeight,
        "%d != %d\n", ret, bm_width_bytes * bm.bmHeight);

    memset(buf, 0xAA, bm.bmWidthBytes * bm.bmHeight + 4096);
    ret = GetBitmapBits(hbm, bm.bmWidthBytes * bm.bmHeight + 4096, buf);
    ok(ret == bm_width_bytes * bm.bmHeight, "%d != %d\n", ret, bm_width_bytes * bm.bmHeight);

    HeapFree(GetProcessHeap(), 0, buf);

    /* test various buffer sizes for GetObject */
    memset(&ds, 0xAA, sizeof(ds));
    ret = GetObjectW(hbm, sizeof(*bma) * 2, bma);
    ok(ret == sizeof(*bma), "wrong size %d\n", ret);
    ok(bm.bmWidth == bmih->biWidth, "wrong bm.bmWidth %d\n", bm.bmWidth);
    ok(bm.bmHeight == abs(bmih->biHeight), "wrong bm.bmHeight %d\n", bm.bmHeight);
    ok(bm.bmBits == bits, "wrong bm.bmBits %p != %p\n", bm.bmBits, bits);

    ret = GetObjectW(hbm, sizeof(bm) / 2, &bm);
    ok(ret == 0, "%d != 0\n", ret);

    ret = GetObjectW(hbm, 0, &bm);
    ok(ret == 0, "%d != 0\n", ret);

    ret = GetObjectW(hbm, 1, &bm);
    ok(ret == 0, "%d != 0\n", ret);

    /* test various buffer sizes for GetObject */
    ret = GetObjectW(hbm, 0, NULL);
    ok(ret == sizeof(bm), "wrong size %d\n", ret);

    ret = GetObjectW(hbm, sizeof(*dsa) * 2, dsa);
    ok(ret == sizeof(*dsa), "wrong size %d\n", ret);

    memset(&ds, 0xAA, sizeof(ds));
    ret = GetObjectW(hbm, sizeof(ds), &ds);
    ok(ret == sizeof(ds), "wrong size %d\n", ret);

    ok(ds.dsBm.bmBits == bits, "wrong bm.bmBits %p != %p\n", ds.dsBm.bmBits, bits);
    if (ds.dsBm.bmWidthBytes != bm_width_bytes) /* Win2k bug */
        ok(ds.dsBmih.biSizeImage == ds.dsBm.bmWidthBytes * ds.dsBm.bmHeight, "%u != %u\n",
           ds.dsBmih.biSizeImage, ds.dsBm.bmWidthBytes * ds.dsBm.bmHeight);
    ok(bmih->biSizeImage == 0, "%u != 0\n", bmih->biSizeImage);
    ds.dsBmih.biSizeImage = 0;

    ok(ds.dsBmih.biSize == bmih->biSize, "%u != %u\n", ds.dsBmih.biSize, bmih->biSize);
    ok(ds.dsBmih.biWidth == bmih->biWidth, "%d != %d\n", ds.dsBmih.biWidth, bmih->biWidth);
    ok(ds.dsBmih.biHeight == abs(bmih->biHeight), "%d != %d\n", ds.dsBmih.biHeight, abs(bmih->biHeight));
    ok(ds.dsBmih.biPlanes == bmih->biPlanes, "%u != %u\n", ds.dsBmih.biPlanes, bmih->biPlanes);
    ok(ds.dsBmih.biBitCount == bmih->biBitCount, "%u != %u\n", ds.dsBmih.biBitCount, bmih->biBitCount);
    ok(ds.dsBmih.biCompression == bmih->biCompression ||
       ((bmih->biBitCount == 32) && broken(ds.dsBmih.biCompression == BI_BITFIELDS)), /* nt4 sp1 and 2 */
       "%u != %u\n", ds.dsBmih.biCompression, bmih->biCompression);
    ok(ds.dsBmih.biSizeImage == bmih->biSizeImage, "%u != %u\n", ds.dsBmih.biSizeImage, bmih->biSizeImage);
    ok(ds.dsBmih.biXPelsPerMeter == bmih->biXPelsPerMeter, "%d != %d\n", ds.dsBmih.biXPelsPerMeter, bmih->biXPelsPerMeter);
    ok(ds.dsBmih.biYPelsPerMeter == bmih->biYPelsPerMeter, "%d != %d\n", ds.dsBmih.biYPelsPerMeter, bmih->biYPelsPerMeter);

    memset(&ds, 0xAA, sizeof(ds));
    ret = GetObjectW(hbm, sizeof(ds) - 4, &ds);
    ok(ret == sizeof(ds.dsBm), "wrong size %d\n", ret);
    ok(ds.dsBm.bmWidth == bmih->biWidth, "%d != %d\n", ds.dsBmih.biWidth, bmih->biWidth);
    ok(ds.dsBm.bmHeight == abs(bmih->biHeight), "%d != %d\n", ds.dsBmih.biHeight, abs(bmih->biHeight));
    ok(ds.dsBm.bmBits == bits, "%p != %p\n", ds.dsBm.bmBits, bits);

    ret = GetObjectW(hbm, 0, &ds);
    ok(ret == 0, "%d != 0\n", ret);

    ret = GetObjectW(hbm, 1, &ds);
    ok(ret == 0, "%d != 0\n", ret);
}

Referenced by test_dibsections().

test_dibsections()

static void test_dibsections ( void  )

static

Definition at line 435 of file bitmap.c.

{
    HDC hdc, hdcmem, hdcmem2;
    HBITMAP hdib, oldbm, hdib2, oldbm2;
    char bmibuf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)];
    char bcibuf[sizeof(BITMAPCOREINFO) + 256 * sizeof(RGBTRIPLE)];
    BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
    BITMAPCOREINFO *pbci = (BITMAPCOREINFO *)bcibuf;
    RGBQUAD *colors = pbmi->bmiColors;
    RGBTRIPLE *ccolors = pbci->bmciColors;
    HBITMAP hcoredib;
    char coreBits[256];
    BYTE *bits;
    RGBQUAD rgb[256];
    int ret;
    char logpalbuf[sizeof(LOGPALETTE) + 256 * sizeof(PALETTEENTRY)];
    LOGPALETTE *plogpal = (LOGPALETTE*)logpalbuf;
    PALETTEENTRY *palent = plogpal->palPalEntry;
    WORD *index;
    DWORD *bits32;
    HPALETTE hpal, oldpal;
    DIBSECTION dibsec;
    COLORREF c0, c1;
    int i;
    MEMORY_BASIC_INFORMATION info;

    hdc = GetDC(0);

    memset(pbmi, 0, sizeof(bmibuf));
    pbmi->bmiHeader.biSize = sizeof(pbmi->bmiHeader);
    pbmi->bmiHeader.biHeight = 100;
    pbmi->bmiHeader.biWidth = 512;
    pbmi->bmiHeader.biBitCount = 24;
    pbmi->bmiHeader.biPlanes = 1;
    pbmi->bmiHeader.biCompression = BI_RGB;

    SetLastError(0xdeadbeef);

    /* invalid pointer for BITMAPINFO
       (*bits should be NULL on error) */
    bits = (BYTE*)0xdeadbeef;
    hdib = CreateDIBSection(hdc, NULL, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(hdib == NULL && bits == NULL, "CreateDIBSection failed for invalid parameter: bmi == 0x0\n");

    hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
    ok(GetObjectW(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIBSection\n");
    ok(dibsec.dsBm.bmBits == bits, "dibsec.dsBits %p != bits %p\n", dibsec.dsBm.bmBits, bits);

    /* test the DIB memory */
    ok(VirtualQuery(bits, &info, sizeof(info)) == sizeof(info),
        "VirtualQuery failed\n");
    ok(info.BaseAddress == bits, "%p != %p\n", info.BaseAddress, bits);
    ok(info.AllocationBase == bits, "%p != %p\n", info.AllocationBase, bits);
    ok(info.AllocationProtect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.AllocationProtect);
    ok(info.RegionSize == 0x26000, "0x%lx != 0x26000\n", info.RegionSize);
    ok(info.State == MEM_COMMIT, "%x != MEM_COMMIT\n", info.State);
    ok(info.Protect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.Protect);
    ok(info.Type == MEM_PRIVATE, "%x != MEM_PRIVATE\n", info.Type);

    test_dib_bits_access( hdib, bits );

    test_dib_info(hdib, bits, &pbmi->bmiHeader);
    DeleteObject(hdib);

    /* Test a top-down DIB. */
    pbmi->bmiHeader.biHeight = -100;
    hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
    test_dib_info(hdib, bits, &pbmi->bmiHeader);
    DeleteObject(hdib);

    pbmi->bmiHeader.biHeight = 100;
    pbmi->bmiHeader.biBitCount = 8;
    pbmi->bmiHeader.biCompression = BI_RLE8;
    SetLastError(0xdeadbeef);
    hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(hdib == NULL, "CreateDIBSection should fail when asked to create a compressed DIB section\n");
    ok(GetLastError() == 0xdeadbeef, "wrong error %d\n", GetLastError());

    pbmi->bmiHeader.biBitCount = 16;
    pbmi->bmiHeader.biCompression = BI_BITFIELDS;
    ((PDWORD)pbmi->bmiColors)[0] = 0xf800;
    ((PDWORD)pbmi->bmiColors)[1] = 0x07e0;
    ((PDWORD)pbmi->bmiColors)[2] = 0x001f;
    SetLastError(0xdeadbeef);
    hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());

    /* test the DIB memory */
    ok(VirtualQuery(bits, &info, sizeof(info)) == sizeof(info),
        "VirtualQuery failed\n");
    ok(info.BaseAddress == bits, "%p != %p\n", info.BaseAddress, bits);
    ok(info.AllocationBase == bits, "%p != %p\n", info.AllocationBase, bits);
    ok(info.AllocationProtect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.AllocationProtect);
    ok(info.RegionSize == 0x19000, "0x%lx != 0x19000\n", info.RegionSize);
    ok(info.State == MEM_COMMIT, "%x != MEM_COMMIT\n", info.State);
    ok(info.Protect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.Protect);
    ok(info.Type == MEM_PRIVATE, "%x != MEM_PRIVATE\n", info.Type);

    test_dib_info(hdib, bits, &pbmi->bmiHeader);
    DeleteObject(hdib);

    memset(pbmi, 0, sizeof(bmibuf));
    pbmi->bmiHeader.biSize = sizeof(pbmi->bmiHeader);
    pbmi->bmiHeader.biHeight = 16;
    pbmi->bmiHeader.biWidth = 16;
    pbmi->bmiHeader.biBitCount = 1;
    pbmi->bmiHeader.biPlanes = 1;
    pbmi->bmiHeader.biCompression = BI_RGB;
    colors[0].rgbRed = 0xff;
    colors[0].rgbGreen = 0;
    colors[0].rgbBlue = 0;
    colors[1].rgbRed = 0;
    colors[1].rgbGreen = 0;
    colors[1].rgbBlue = 0xff;

    hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(hdib != NULL, "CreateDIBSection failed\n");
    ok(GetObjectW(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIBSection\n");
    ok(dibsec.dsBmih.biClrUsed == 2,
        "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 2);

    /* Test if the old BITMAPCOREINFO structure is supported */

    pbci->bmciHeader.bcSize = sizeof(BITMAPCOREHEADER);
    pbci->bmciHeader.bcBitCount = 0;

    ret = GetDIBits(hdc, hdib, 0, 16, NULL, (BITMAPINFO*) pbci, DIB_RGB_COLORS);
    ok(ret, "GetDIBits doesn't work with a BITMAPCOREHEADER\n");
    ok((pbci->bmciHeader.bcWidth == 16) && (pbci->bmciHeader.bcHeight == 16)
        && (pbci->bmciHeader.bcBitCount == 1) && (pbci->bmciHeader.bcPlanes == 1),
    "GetDIBits didn't fill in the BITMAPCOREHEADER structure properly\n");

    ret = GetDIBits(hdc, hdib, 0, 16, &coreBits, (BITMAPINFO*) pbci, DIB_RGB_COLORS);
    ok(ret, "GetDIBits doesn't work with a BITMAPCOREHEADER\n");
    ok((ccolors[0].rgbtRed == 0xff) && (ccolors[0].rgbtGreen == 0) &&
        (ccolors[0].rgbtBlue == 0) && (ccolors[1].rgbtRed == 0) &&
        (ccolors[1].rgbtGreen == 0) && (ccolors[1].rgbtBlue == 0xff),
        "The color table has not been translated to the old BITMAPCOREINFO format\n");

    hcoredib = CreateDIBSection(hdc, (BITMAPINFO*) pbci, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
    ok(hcoredib != NULL, "CreateDIBSection failed with a BITMAPCOREINFO\n");

    ZeroMemory(ccolors, 256 * sizeof(RGBTRIPLE));
    ret = GetDIBits(hdc, hcoredib, 0, 16, &coreBits, (BITMAPINFO*) pbci, DIB_RGB_COLORS);
    ok(ret, "GetDIBits doesn't work with a BITMAPCOREHEADER\n");
    ok((ccolors[0].rgbtRed == 0xff) && (ccolors[0].rgbtGreen == 0) &&
        (ccolors[0].rgbtBlue == 0) && (ccolors[1].rgbtRed == 0) &&
        (ccolors[1].rgbtGreen == 0) && (ccolors[1].rgbtBlue == 0xff),
        "The color table has not been translated to the old BITMAPCOREINFO format\n");

    DeleteObject(hcoredib);

    hdcmem = CreateCompatibleDC(hdc);
    oldbm = SelectObject(hdcmem, hdib);

    ret = GetDIBColorTable(hdcmem, 0, 2, rgb);
    ok(ret == 2, "GetDIBColorTable returned %d\n", ret);
    ok(!memcmp(rgb, pbmi->bmiColors, 2 * sizeof(RGBQUAD)),
       "GetDIBColorTable returns table 0: r%02x g%02x b%02x res%02x 1: r%02x g%02x b%02x res%02x\n",
       rgb[0].rgbRed, rgb[0].rgbGreen, rgb[0].rgbBlue, rgb[0].rgbReserved,
       rgb[1].rgbRed, rgb[1].rgbGreen, rgb[1].rgbBlue, rgb[1].rgbReserved);

    c0 = RGB(colors[0].rgbRed, colors[0].rgbGreen, colors[0].rgbBlue);
    c1 = RGB(colors[1].rgbRed, colors[1].rgbGreen, colors[1].rgbBlue);

    test_color(hdcmem, DIBINDEX(0), c0);
    test_color(hdcmem, DIBINDEX(1), c1);
    test_color(hdcmem, DIBINDEX(2), c0);
    test_color(hdcmem, PALETTEINDEX(0), c0);
    test_color(hdcmem, PALETTEINDEX(1), c0);
    test_color(hdcmem, PALETTEINDEX(2), c0);
    test_color(hdcmem, PALETTERGB(colors[0].rgbRed, colors[0].rgbGreen, colors[0].rgbBlue), c0);
    test_color(hdcmem, PALETTERGB(colors[1].rgbRed, colors[1].rgbGreen, colors[1].rgbBlue), c1);
    test_color(hdcmem, PALETTERGB(0, 0, 0), c0);
    test_color(hdcmem, PALETTERGB(0xff, 0xff, 0xff), c0);
    test_color(hdcmem, PALETTERGB(0, 0, 0xfe), c1);

    SelectObject(hdcmem, oldbm);
    DeleteObject(hdib);

    colors[0].rgbRed = 0xff;
    colors[0].rgbGreen = 0xff;
    colors[0].rgbBlue = 0xff;
    colors[1].rgbRed = 0;
    colors[1].r