2 * Unit test suite for bitmaps
4 * Copyright 2004 Huw Davies
5 * Copyright 2006 Dmitry Timoshkov
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
33 #include "wine/test.h"
35 static BOOL (WINAPI
*pGdiAlphaBlend
)(HDC
,int,int,int,int,HDC
,int,int,int,int,BLENDFUNCTION
);
37 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
41 static INT
BITMAP_GetWidthBytes( INT bmWidth
, INT bpp
)
46 return 2 * ((bmWidth
+15) >> 4);
49 bmWidth
*= 3; /* fall through */
51 return bmWidth
+ (bmWidth
& 1);
61 return 2 * ((bmWidth
+3) >> 2);
64 trace("Unknown depth %d, please report.\n", bpp
);
70 static void test_bitmap_info(HBITMAP hbm
, INT expected_depth
, const BITMAPINFOHEADER
*bmih
)
75 char buf
[512], buf_cmp
[512];
78 ret
= GetObject(hbm
, sizeof(bm
), &bm
);
79 ok(ret
== sizeof(bm
), "GetObject returned %d\n", ret
);
81 ok(bm
.bmType
== 0 || broken(bm
.bmType
== 21072 /* Win9x */), "wrong bm.bmType %d\n", bm
.bmType
);
82 ok(bm
.bmWidth
== bmih
->biWidth
, "wrong bm.bmWidth %d\n", bm
.bmWidth
);
83 ok(bm
.bmHeight
== bmih
->biHeight
, "wrong bm.bmHeight %d\n", bm
.bmHeight
);
84 width_bytes
= BITMAP_GetWidthBytes(bm
.bmWidth
, bm
.bmBitsPixel
);
85 ok(bm
.bmWidthBytes
== width_bytes
, "wrong bm.bmWidthBytes %d != %d\n", bm
.bmWidthBytes
, width_bytes
);
86 ok(bm
.bmPlanes
== bmih
->biPlanes
, "wrong bm.bmPlanes %d\n", bm
.bmPlanes
);
87 ok(bm
.bmBitsPixel
== expected_depth
, "wrong bm.bmBitsPixel %d != %d\n", bm
.bmBitsPixel
, expected_depth
);
88 ok(bm
.bmBits
== NULL
, "wrong bm.bmBits %p\n", bm
.bmBits
);
90 assert(sizeof(buf
) >= bm
.bmWidthBytes
* bm
.bmHeight
);
91 assert(sizeof(buf
) == sizeof(buf_cmp
));
93 SetLastError(0xdeadbeef);
94 ret
= GetBitmapBits(hbm
, 0, NULL
);
96 ok(ret
== bm
.bmWidthBytes
* bm
.bmHeight
|| (ret
== 0 && gle
== ERROR_INVALID_PARAMETER
/* Win9x */), "%d != %d\n", ret
, bm
.bmWidthBytes
* bm
.bmHeight
);
98 memset(buf_cmp
, 0xAA, sizeof(buf_cmp
));
99 memset(buf_cmp
, 0, bm
.bmWidthBytes
* bm
.bmHeight
);
101 memset(buf
, 0xAA, sizeof(buf
));
102 ret
= GetBitmapBits(hbm
, sizeof(buf
), buf
);
103 ok(ret
== bm
.bmWidthBytes
* bm
.bmHeight
, "%d != %d\n", ret
, bm
.bmWidthBytes
* bm
.bmHeight
);
104 ok(!memcmp(buf
, buf_cmp
, sizeof(buf
)), "buffers do not match\n");
106 /* test various buffer sizes for GetObject */
107 ret
= GetObject(hbm
, sizeof(*bma
) * 2, bma
);
108 ok(ret
== sizeof(*bma
) || broken(ret
== sizeof(*bma
) * 2 /* Win9x */), "wrong size %d\n", ret
);
110 ret
= GetObject(hbm
, sizeof(bm
) / 2, &bm
);
111 ok(ret
== 0 || broken(ret
== sizeof(bm
) / 2 /* Win9x */), "%d != 0\n", ret
);
113 ret
= GetObject(hbm
, 0, &bm
);
114 ok(ret
== 0, "%d != 0\n", ret
);
116 ret
= GetObject(hbm
, 1, &bm
);
117 ok(ret
== 0 || broken(ret
== 1 /* Win9x */), "%d != 0\n", ret
);
119 /* Don't trust Win9x not to try to write to NULL */
122 ret
= GetObject(hbm
, 0, NULL
);
123 ok(ret
== sizeof(bm
), "wrong size %d\n", ret
);
127 static void test_createdibitmap(void)
130 BITMAPINFOHEADER bmih
;
132 HBITMAP hbm
, hbm_colour
, hbm_old
;
137 screen_depth
= GetDeviceCaps(hdc
, BITSPIXEL
);
138 memset(&bmih
, 0, sizeof(bmih
));
139 bmih
.biSize
= sizeof(bmih
);
143 bmih
.biBitCount
= 32;
144 bmih
.biCompression
= BI_RGB
;
146 /* First create an un-initialised bitmap. The depth of the bitmap
147 should match that of the hdc and not that supplied in bmih.
150 /* First try 32 bits */
151 hbm
= CreateDIBitmap(hdc
, &bmih
, 0, NULL
, NULL
, 0);
152 ok(hbm
!= NULL
, "CreateDIBitmap failed\n");
153 test_bitmap_info(hbm
, screen_depth
, &bmih
);
157 bmih
.biBitCount
= 16;
158 hbm
= CreateDIBitmap(hdc
, &bmih
, 0, NULL
, NULL
, 0);
159 ok(hbm
!= NULL
, "CreateDIBitmap failed\n");
160 test_bitmap_info(hbm
, screen_depth
, &bmih
);
165 hbm
= CreateDIBitmap(hdc
, &bmih
, 0, NULL
, NULL
, 0);
166 ok(hbm
!= NULL
, "CreateDIBitmap failed\n");
167 test_bitmap_info(hbm
, screen_depth
, &bmih
);
170 /* Now with a monochrome dc we expect a monochrome bitmap */
171 hdcmem
= CreateCompatibleDC(hdc
);
173 /* First try 32 bits */
174 bmih
.biBitCount
= 32;
175 hbm
= CreateDIBitmap(hdcmem
, &bmih
, 0, NULL
, NULL
, 0);
176 ok(hbm
!= NULL
, "CreateDIBitmap failed\n");
177 test_bitmap_info(hbm
, 1, &bmih
);
181 bmih
.biBitCount
= 16;
182 hbm
= CreateDIBitmap(hdcmem
, &bmih
, 0, NULL
, NULL
, 0);
183 ok(hbm
!= NULL
, "CreateDIBitmap failed\n");
184 test_bitmap_info(hbm
, 1, &bmih
);
189 hbm
= CreateDIBitmap(hdcmem
, &bmih
, 0, NULL
, NULL
, 0);
190 ok(hbm
!= NULL
, "CreateDIBitmap failed\n");
191 test_bitmap_info(hbm
, 1, &bmih
);
194 /* Now select a polychrome bitmap into the dc and we expect
195 screen_depth bitmaps again */
196 hbm_colour
= CreateCompatibleBitmap(hdc
, bmih
.biWidth
, bmih
.biHeight
);
197 test_bitmap_info(hbm_colour
, screen_depth
, &bmih
);
198 hbm_old
= SelectObject(hdcmem
, hbm_colour
);
200 /* First try 32 bits */
201 bmih
.biBitCount
= 32;
202 hbm
= CreateDIBitmap(hdcmem
, &bmih
, 0, NULL
, NULL
, 0);
203 ok(hbm
!= NULL
, "CreateDIBitmap failed\n");
204 test_bitmap_info(hbm
, screen_depth
, &bmih
);
208 bmih
.biBitCount
= 16;
209 hbm
= CreateDIBitmap(hdcmem
, &bmih
, 0, NULL
, NULL
, 0);
210 ok(hbm
!= NULL
, "CreateDIBitmap failed\n");
211 test_bitmap_info(hbm
, screen_depth
, &bmih
);
216 hbm
= CreateDIBitmap(hdcmem
, &bmih
, 0, NULL
, NULL
, 0);
217 ok(hbm
!= NULL
, "CreateDIBitmap failed\n");
218 test_bitmap_info(hbm
, screen_depth
, &bmih
);
221 SelectObject(hdcmem
, hbm_old
);
222 DeleteObject(hbm_colour
);
225 /* If hdc == 0 then we get a 1 bpp bitmap */
227 bmih
.biBitCount
= 32;
228 hbm
= CreateDIBitmap(0, &bmih
, 0, NULL
, NULL
, 0);
229 ok(hbm
!= NULL
, "CreateDIBitmap failed\n");
230 test_bitmap_info(hbm
, 1, &bmih
);
234 /* Test how formats are converted */
240 memset(&bm
, 0, sizeof(bm
));
241 bm
.bmiHeader
.biSize
= sizeof(bm
.bmiHeader
);
242 bm
.bmiHeader
.biWidth
= 1;
243 bm
.bmiHeader
.biHeight
= 1;
244 bm
.bmiHeader
.biPlanes
= 1;
245 bm
.bmiHeader
.biBitCount
= 24;
246 bm
.bmiHeader
.biCompression
= BI_RGB
;
247 bm
.bmiHeader
.biSizeImage
= 0;
248 hbm
= CreateDIBitmap(hdc
, &bmih
, CBM_INIT
, &pixel
, &bm
, DIB_RGB_COLORS
);
249 ok(hbm
!= NULL
, "CreateDIBitmap failed\n");
252 bm
.bmiHeader
.biBitCount
= 32;
253 GetDIBits(hdc
, hbm
, 0, 1, &pixel
, &bm
, DIB_RGB_COLORS
);
254 ok(pixel
== 0x00ffffff, "Reading a 32 bit pixel from a DDB returned %08x\n", pixel
);
260 static INT
DIB_GetWidthBytes( int width
, int bpp
)
266 case 1: words
= (width
+ 31) / 32; break;
267 case 4: words
= (width
+ 7) / 8; break;
268 case 8: words
= (width
+ 3) / 4; break;
270 case 16: words
= (width
+ 1) / 2; break;
271 case 24: words
= (width
* 3 + 3)/4; break;
272 case 32: words
= width
; break;
276 trace("Unknown depth %d, please report.\n", bpp
);
283 static void test_dib_info(HBITMAP hbm
, const void *bits
, const BITMAPINFOHEADER
*bmih
)
289 INT ret
, bm_width_bytes
, dib_width_bytes
;
292 ret
= GetObject(hbm
, sizeof(bm
), &bm
);
293 ok(ret
== sizeof(bm
), "GetObject returned %d\n", ret
);
295 ok(bm
.bmType
== 0, "wrong bm.bmType %d\n", bm
.bmType
);
296 ok(bm
.bmWidth
== bmih
->biWidth
, "wrong bm.bmWidth %d\n", bm
.bmWidth
);
297 ok(bm
.bmHeight
== bmih
->biHeight
, "wrong bm.bmHeight %d\n", bm
.bmHeight
);
298 dib_width_bytes
= DIB_GetWidthBytes(bm
.bmWidth
, bm
.bmBitsPixel
);
299 bm_width_bytes
= BITMAP_GetWidthBytes(bm
.bmWidth
, bm
.bmBitsPixel
);
300 if (bm
.bmWidthBytes
!= dib_width_bytes
) /* Win2k bug */
301 ok(bm
.bmWidthBytes
== bm_width_bytes
, "wrong bm.bmWidthBytes %d != %d\n", bm
.bmWidthBytes
, bm_width_bytes
);
303 ok(bm
.bmWidthBytes
== dib_width_bytes
, "wrong bm.bmWidthBytes %d != %d\n", bm
.bmWidthBytes
, dib_width_bytes
);
304 ok(bm
.bmPlanes
== bmih
->biPlanes
, "wrong bm.bmPlanes %d\n", bm
.bmPlanes
);
305 ok(bm
.bmBitsPixel
== bmih
->biBitCount
, "bm.bmBitsPixel %d != %d\n", bm
.bmBitsPixel
, bmih
->biBitCount
);
306 ok(bm
.bmBits
== bits
, "wrong bm.bmBits %p != %p\n", bm
.bmBits
, bits
);
308 buf
= HeapAlloc(GetProcessHeap(), 0, bm
.bmWidthBytes
* bm
.bmHeight
+ 4096);
310 /* GetBitmapBits returns not 32-bit aligned data */
311 ret
= GetBitmapBits(hbm
, 0, NULL
);
312 ok(ret
== bm_width_bytes
* bm
.bmHeight
, "%d != %d\n", ret
, bm_width_bytes
* bm
.bmHeight
);
314 memset(buf
, 0xAA, bm
.bmWidthBytes
* bm
.bmHeight
+ 4096);
315 ret
= GetBitmapBits(hbm
, bm
.bmWidthBytes
* bm
.bmHeight
+ 4096, buf
);
316 ok(ret
== bm_width_bytes
* bm
.bmHeight
, "%d != %d\n", ret
, bm_width_bytes
* bm
.bmHeight
);
318 HeapFree(GetProcessHeap(), 0, buf
);
320 /* test various buffer sizes for GetObject */
321 memset(&ds
, 0xAA, sizeof(ds
));
322 ret
= GetObject(hbm
, sizeof(*bma
) * 2, bma
);
323 ok(ret
== sizeof(*bma
) || broken(ret
== sizeof(*bma
) * 2 /* Win9x */), "wrong size %d\n", ret
);
324 ok(bm
.bmWidth
== bmih
->biWidth
, "wrong bm.bmWidth %d\n", bm
.bmWidth
);
325 ok(bm
.bmHeight
== bmih
->biHeight
, "wrong bm.bmHeight %d\n", bm
.bmHeight
);
326 ok(bm
.bmBits
== bits
, "wrong bm.bmBits %p != %p\n", bm
.bmBits
, bits
);
328 ret
= GetObject(hbm
, sizeof(bm
) / 2, &bm
);
329 ok(ret
== 0 || broken(ret
== sizeof(bm
) / 2 /* Win9x */), "%d != 0\n", ret
);
331 ret
= GetObject(hbm
, 0, &bm
);
332 ok(ret
== 0, "%d != 0\n", ret
);
334 ret
= GetObject(hbm
, 1, &bm
);
335 ok(ret
== 0 || broken(ret
== 1 /* Win9x */), "%d != 0\n", ret
);
337 /* test various buffer sizes for GetObject */
338 ret
= GetObject(hbm
, 0, NULL
);
339 ok(ret
== sizeof(bm
), "wrong size %d\n", ret
);
341 ret
= GetObject(hbm
, sizeof(*dsa
) * 2, dsa
);
342 ok(ret
== sizeof(*dsa
) || broken(ret
== sizeof(*dsa
) * 2 /* Win9x */), "wrong size %d\n", ret
);
344 memset(&ds
, 0xAA, sizeof(ds
));
345 ret
= GetObject(hbm
, sizeof(ds
), &ds
);
346 ok(ret
== sizeof(ds
), "wrong size %d\n", ret
);
348 ok(ds
.dsBm
.bmBits
== bits
, "wrong bm.bmBits %p != %p\n", ds
.dsBm
.bmBits
, bits
);
349 if (ds
.dsBm
.bmWidthBytes
!= bm_width_bytes
) /* Win2k bug */
350 ok(ds
.dsBmih
.biSizeImage
== ds
.dsBm
.bmWidthBytes
* ds
.dsBm
.bmHeight
, "%u != %u\n",
351 ds
.dsBmih
.biSizeImage
, ds
.dsBm
.bmWidthBytes
* ds
.dsBm
.bmHeight
);
352 ok(bmih
->biSizeImage
== 0, "%u != 0\n", bmih
->biSizeImage
);
353 ds
.dsBmih
.biSizeImage
= 0;
355 ok(ds
.dsBmih
.biSize
== bmih
->biSize
, "%u != %u\n", ds
.dsBmih
.biSize
, bmih
->biSize
);
356 ok(ds
.dsBmih
.biWidth
== bmih
->biWidth
, "%u != %u\n", ds
.dsBmih
.biWidth
, bmih
->biWidth
);
357 ok(ds
.dsBmih
.biHeight
== bmih
->biHeight
, "%u != %u\n", ds
.dsBmih
.biHeight
, bmih
->biHeight
);
358 ok(ds
.dsBmih
.biPlanes
== bmih
->biPlanes
, "%u != %u\n", ds
.dsBmih
.biPlanes
, bmih
->biPlanes
);
359 ok(ds
.dsBmih
.biBitCount
== bmih
->biBitCount
, "%u != %u\n", ds
.dsBmih
.biBitCount
, bmih
->biBitCount
);
360 ok(ds
.dsBmih
.biCompression
== bmih
->biCompression
, "%u != %u\n", ds
.dsBmih
.biCompression
, bmih
->biCompression
);
361 ok(ds
.dsBmih
.biSizeImage
== bmih
->biSizeImage
, "%u != %u\n", ds
.dsBmih
.biSizeImage
, bmih
->biSizeImage
);
362 ok(ds
.dsBmih
.biXPelsPerMeter
== bmih
->biXPelsPerMeter
, "%u != %u\n", ds
.dsBmih
.biXPelsPerMeter
, bmih
->biXPelsPerMeter
);
363 ok(ds
.dsBmih
.biYPelsPerMeter
== bmih
->biYPelsPerMeter
, "%u != %u\n", ds
.dsBmih
.biYPelsPerMeter
, bmih
->biYPelsPerMeter
);
365 memset(&ds
, 0xAA, sizeof(ds
));
366 ret
= GetObject(hbm
, sizeof(ds
) - 4, &ds
);
367 ok(ret
== sizeof(ds
.dsBm
), "wrong size %d\n", ret
);
368 ok(ds
.dsBm
.bmWidth
== bmih
->biWidth
, "%u != %u\n", ds
.dsBmih
.biWidth
, bmih
->biWidth
);
369 ok(ds
.dsBm
.bmHeight
== bmih
->biHeight
, "%u != %u\n", ds
.dsBmih
.biHeight
, bmih
->biHeight
);
370 ok(ds
.dsBm
.bmBits
== bits
, "%p != %p\n", ds
.dsBm
.bmBits
, bits
);
372 ret
= GetObject(hbm
, 0, &ds
);
373 ok(ret
== 0, "%d != 0\n", ret
);
375 ret
= GetObject(hbm
, 1, &ds
);
376 ok(ret
== 0, "%d != 0\n", ret
);
379 #define test_color_todo(got, exp, txt, todo) \
380 if (!todo && got != exp && screen_depth < 24) { \
381 todo_wine ok(0, #txt " failed at %d-bit screen depth: got 0x%06x expected 0x%06x - skipping DIB tests\n", \
382 screen_depth, (UINT)got, (UINT)exp); \
384 } else if (todo) todo_wine { ok(got == exp, #txt " failed: got 0x%06x expected 0x%06x\n", (UINT)got, (UINT)exp); } \
385 else ok(got == exp, #txt " failed: got 0x%06x expected 0x%06x\n", (UINT)got, (UINT)exp) \
387 #define test_color(hdc, color, exp, todo_setp, todo_getp) \
390 c = SetPixel(hdc, 0, 0, color); \
391 if (!is_win9x) { test_color_todo(c, exp, SetPixel, todo_setp); } \
392 c = GetPixel(hdc, 0, 0); \
393 test_color_todo(c, exp, GetPixel, todo_getp); \
396 static void test_dibsections(void)
398 HDC hdc
, hdcmem
, hdcmem2
;
399 HBITMAP hdib
, oldbm
, hdib2
, oldbm2
;
400 char bmibuf
[sizeof(BITMAPINFO
) + 256 * sizeof(RGBQUAD
)];
401 char bcibuf
[sizeof(BITMAPCOREINFO
) + 256 * sizeof(RGBTRIPLE
)];
402 BITMAPINFO
*pbmi
= (BITMAPINFO
*)bmibuf
;
403 BITMAPCOREINFO
*pbci
= (BITMAPCOREINFO
*)bcibuf
;
409 char logpalbuf
[sizeof(LOGPALETTE
) + 256 * sizeof(PALETTEENTRY
)];
410 LOGPALETTE
*plogpal
= (LOGPALETTE
*)logpalbuf
;
413 HPALETTE hpal
, oldpal
;
418 MEMORY_BASIC_INFORMATION info
;
421 screen_depth
= GetDeviceCaps(hdc
, BITSPIXEL
) * GetDeviceCaps(hdc
, PLANES
);
423 memset(pbmi
, 0, sizeof(bmibuf
));
424 pbmi
->bmiHeader
.biSize
= sizeof(pbmi
->bmiHeader
);
425 pbmi
->bmiHeader
.biHeight
= 100;
426 pbmi
->bmiHeader
.biWidth
= 512;
427 pbmi
->bmiHeader
.biBitCount
= 24;
428 pbmi
->bmiHeader
.biPlanes
= 1;
429 pbmi
->bmiHeader
.biCompression
= BI_RGB
;
431 SetLastError(0xdeadbeef);
433 /* invalid pointer for BITMAPINFO
434 (*bits should be NULL on error) */
435 bits
= (BYTE
*)0xdeadbeef;
436 hdib
= CreateDIBSection(hdc
, NULL
, DIB_RGB_COLORS
, (void**)&bits
, NULL
, 0);
437 ok(hdib
== NULL
&& bits
== NULL
, "CreateDIBSection failed for invalid parameter: bmi == 0x0\n");
439 hdib
= CreateDIBSection(hdc
, pbmi
, DIB_RGB_COLORS
, (void**)&bits
, NULL
, 0);
440 ok(hdib
!= NULL
, "CreateDIBSection error %d\n", GetLastError());
441 ok(GetObject(hdib
, sizeof(DIBSECTION
), &dibsec
) != 0, "GetObject failed for DIBSection\n");
442 ok(dibsec
.dsBm
.bmBits
== bits
, "dibsec.dsBits %p != bits %p\n", dibsec
.dsBm
.bmBits
, bits
);
444 /* test the DIB memory */
445 ok(VirtualQuery(bits
, &info
, sizeof(info
)) == sizeof(info
),
446 "VirtualQuery failed\n");
447 ok(info
.BaseAddress
== bits
, "%p != %p\n", info
.BaseAddress
, bits
);
448 ok(info
.AllocationBase
== bits
, "%p != %p\n", info
.AllocationBase
, bits
);
449 ok(info
.AllocationProtect
== PAGE_READWRITE
, "%x != PAGE_READWRITE\n", info
.AllocationProtect
);
450 ok(info
.RegionSize
== 0x26000, "0x%lx != 0x26000\n", info
.RegionSize
);
451 ok(info
.State
== MEM_COMMIT
, "%x != MEM_COMMIT\n", info
.State
);
452 ok(info
.Protect
== PAGE_READWRITE
, "%x != PAGE_READWRITE\n", info
.Protect
);
453 ok(info
.Type
== MEM_PRIVATE
, "%x != MEM_PRIVATE\n", info
.Type
);
455 test_dib_info(hdib
, bits
, &pbmi
->bmiHeader
);
458 pbmi
->bmiHeader
.biBitCount
= 8;
459 pbmi
->bmiHeader
.biCompression
= BI_RLE8
;
460 SetLastError(0xdeadbeef);
461 hdib
= CreateDIBSection(hdc
, pbmi
, DIB_RGB_COLORS
, (void**)&bits
, NULL
, 0);
462 ok(hdib
== NULL
, "CreateDIBSection should fail when asked to create a compressed DIB section\n");
463 ok(GetLastError() == 0xdeadbeef, "wrong error %d\n", GetLastError());
465 pbmi
->bmiHeader
.biBitCount
= 16;
466 pbmi
->bmiHeader
.biCompression
= BI_BITFIELDS
;
467 ((PDWORD
)pbmi
->bmiColors
)[0] = 0xf800;
468 ((PDWORD
)pbmi
->bmiColors
)[1] = 0x07e0;
469 ((PDWORD
)pbmi
->bmiColors
)[2] = 0x001f;
470 SetLastError(0xdeadbeef);
471 hdib
= CreateDIBSection(hdc
, pbmi
, DIB_RGB_COLORS
, (void**)&bits
, NULL
, 0);
472 ok(hdib
!= NULL
, "CreateDIBSection error %d\n", GetLastError());
474 /* test the DIB memory */
475 ok(VirtualQuery(bits
, &info
, sizeof(info
)) == sizeof(info
),
476 "VirtualQuery failed\n");
477 ok(info
.BaseAddress
== bits
, "%p != %p\n", info
.BaseAddress
, bits
);
478 ok(info
.AllocationBase
== bits
, "%p != %p\n", info
.AllocationBase
, bits
);
479 ok(info
.AllocationProtect
== PAGE_READWRITE
, "%x != PAGE_READWRITE\n", info
.AllocationProtect
);
480 ok(info
.RegionSize
== 0x19000, "0x%lx != 0x19000\n", info
.RegionSize
);
481 ok(info
.State
== MEM_COMMIT
, "%x != MEM_COMMIT\n", info
.State
);
482 ok(info
.Protect
== PAGE_READWRITE
, "%x != PAGE_READWRITE\n", info
.Protect
);
483 ok(info
.Type
== MEM_PRIVATE
, "%x != MEM_PRIVATE\n", info
.Type
);
485 test_dib_info(hdib
, bits
, &pbmi
->bmiHeader
);
488 memset(pbmi
, 0, sizeof(bmibuf
));
489 pbmi
->bmiHeader
.biSize
= sizeof(pbmi
->bmiHeader
);
490 pbmi
->bmiHeader
.biHeight
= 16;
491 pbmi
->bmiHeader
.biWidth
= 16;
492 pbmi
->bmiHeader
.biBitCount
= 1;
493 pbmi
->bmiHeader
.biPlanes
= 1;
494 pbmi
->bmiHeader
.biCompression
= BI_RGB
;
495 pbmi
->bmiColors
[0].rgbRed
= 0xff;
496 pbmi
->bmiColors
[0].rgbGreen
= 0;
497 pbmi
->bmiColors
[0].rgbBlue
= 0;
498 pbmi
->bmiColors
[1].rgbRed
= 0;
499 pbmi
->bmiColors
[1].rgbGreen
= 0;
500 pbmi
->bmiColors
[1].rgbBlue
= 0xff;
502 hdib
= CreateDIBSection(hdc
, pbmi
, DIB_RGB_COLORS
, (void**)&bits
, NULL
, 0);
503 ok(hdib
!= NULL
, "CreateDIBSection failed\n");
504 ok(GetObject(hdib
, sizeof(DIBSECTION
), &dibsec
) != 0, "GetObject failed for DIBSection\n");
505 ok(dibsec
.dsBmih
.biClrUsed
== 2,
506 "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec
.dsBmih
.biClrUsed
, 2);
508 /* Test if the old BITMAPCOREINFO structure is supported */
510 pbci
->bmciHeader
.bcSize
= sizeof(BITMAPCOREHEADER
);
511 pbci
->bmciHeader
.bcBitCount
= 0;
514 ret
= GetDIBits(hdc
, hdib
, 0, 16, NULL
, (BITMAPINFO
*) pbci
, DIB_RGB_COLORS
);
515 ok(ret
, "GetDIBits doesn't work with a BITMAPCOREHEADER\n");
516 ok((pbci
->bmciHeader
.bcWidth
== 16) && (pbci
->bmciHeader
.bcHeight
== 16)
517 && (pbci
->bmciHeader
.bcBitCount
== 1) && (pbci
->bmciHeader
.bcPlanes
== 1),
518 "GetDIBits did't fill in the BITMAPCOREHEADER structure properly\n");
520 ret
= GetDIBits(hdc
, hdib
, 0, 16, &coreBits
, (BITMAPINFO
*) pbci
, DIB_RGB_COLORS
);
521 ok(ret
, "GetDIBits doesn't work with a BITMAPCOREHEADER\n");
522 ok((pbci
->bmciColors
[0].rgbtRed
== 0xff) && (pbci
->bmciColors
[0].rgbtGreen
== 0) &&
523 (pbci
->bmciColors
[0].rgbtBlue
== 0) && (pbci
->bmciColors
[1].rgbtRed
== 0) &&
524 (pbci
->bmciColors
[1].rgbtGreen
== 0) && (pbci
->bmciColors
[1].rgbtBlue
== 0xff),
525 "The color table has not been translated to the old BITMAPCOREINFO format\n");
527 hcoredib
= CreateDIBSection(hdc
, (BITMAPINFO
*) pbci
, DIB_RGB_COLORS
, (void**)&bits
, NULL
, 0);
528 ok(hcoredib
!= NULL
, "CreateDIBSection failed with a BITMAPCOREINFO\n");
530 ZeroMemory(pbci
->bmciColors
, 256 * sizeof(RGBTRIPLE
));
531 ret
= GetDIBits(hdc
, hcoredib
, 0, 16, &coreBits
, (BITMAPINFO
*) pbci
, DIB_RGB_COLORS
);
532 ok(ret
, "GetDIBits doesn't work with a BITMAPCOREHEADER\n");
533 ok((pbci
->bmciColors
[0].rgbtRed
== 0xff) && (pbci
->bmciColors
[0].rgbtGreen
== 0) &&
534 (pbci
->bmciColors
[0].rgbtBlue
== 0) && (pbci
->bmciColors
[1].rgbtRed
== 0) &&
535 (pbci
->bmciColors
[1].rgbtGreen
== 0) && (pbci
->bmciColors
[1].rgbtBlue
== 0xff),
536 "The color table has not been translated to the old BITMAPCOREINFO format\n");
538 DeleteObject(hcoredib
);
541 hdcmem
= CreateCompatibleDC(hdc
);
542 oldbm
= SelectObject(hdcmem
, hdib
);
544 ret
= GetDIBColorTable(hdcmem
, 0, 2, rgb
);
545 ok(ret
== 2, "GetDIBColorTable returned %d\n", ret
);
546 ok(!memcmp(rgb
, pbmi
->bmiColors
, 2 * sizeof(RGBQUAD
)),
547 "GetDIBColorTable returns table 0: r%02x g%02x b%02x res%02x 1: r%02x g%02x b%02x res%02x\n",
548 rgb
[0].rgbRed
, rgb
[0].rgbGreen
, rgb
[0].rgbBlue
, rgb
[0].rgbReserved
,
549 rgb
[1].rgbRed
, rgb
[1].rgbGreen
, rgb
[1].rgbBlue
, rgb
[1].rgbReserved
);
551 c0
= RGB(pbmi
->bmiColors
[0].rgbRed
, pbmi
->bmiColors
[0].rgbGreen
, pbmi
->bmiColors
[0].rgbBlue
);
552 c1
= RGB(pbmi
->bmiColors
[1].rgbRed
, pbmi
->bmiColors
[1].rgbGreen
, pbmi
->bmiColors
[1].rgbBlue
);
554 test_color(hdcmem
, DIBINDEX(0), c0
, 0, 1);
555 test_color(hdcmem
, DIBINDEX(1), c1
, 0, 1);
556 test_color(hdcmem
, DIBINDEX(2), c0
, 1, 1);
557 test_color(hdcmem
, PALETTEINDEX(0), c0
, 1, 1);
558 test_color(hdcmem
, PALETTEINDEX(1), c0
, 1, 1);
559 test_color(hdcmem
, PALETTEINDEX(2), c0
, 1, 1);
560 test_color(hdcmem
, PALETTERGB(pbmi
->bmiColors
[0].rgbRed
, pbmi
->bmiColors
[0].rgbGreen
,
561 pbmi
->bmiColors
[0].rgbBlue
), c0
, 1, 1);
562 test_color(hdcmem
, PALETTERGB(pbmi
->bmiColors
[1].rgbRed
, pbmi
->bmiColors
[1].rgbGreen
,
563 pbmi
->bmiColors
[1].rgbBlue
), c1
, 1, 1);
564 test_color(hdcmem
, PALETTERGB(0, 0, 0), c0
, 1, 1);
565 test_color(hdcmem
, PALETTERGB(0xff, 0xff, 0xff), c0
, 1, 1);
566 test_color(hdcmem
, PALETTERGB(0, 0, 0xfe), c1
, 1, 1);
568 SelectObject(hdcmem
, oldbm
);
571 pbmi
->bmiColors
[0].rgbRed
= 0xff;
572 pbmi
->bmiColors
[0].rgbGreen
= 0xff;
573 pbmi
->bmiColors
[0].rgbBlue
= 0xff;
574 pbmi
->bmiColors
[1].rgbRed
= 0;
575 pbmi
->bmiColors
[1].rgbGreen
= 0;
576 pbmi
->bmiColors
[1].rgbBlue
= 0;
578 hdib
= CreateDIBSection(hdc
, pbmi
, DIB_RGB_COLORS
, (void**)&bits
, NULL
, 0);
579 ok(hdib
!= NULL
, "CreateDIBSection failed\n");
581 test_dib_info(hdib
, bits
, &pbmi
->bmiHeader
);
583 oldbm
= SelectObject(hdcmem
, hdib
);
585 ret
= GetDIBColorTable(hdcmem
, 0, 2, rgb
);
586 ok(ret
== 2, "GetDIBColorTable returned %d\n", ret
);
587 ok(!memcmp(rgb
, pbmi
->bmiColors
, 2 * sizeof(RGBQUAD
)),
588 "GetDIBColorTable returns table 0: r%02x g%02x b%02x res%02x 1: r%02x g%02x b%02x res%02x\n",
589 rgb
[0].rgbRed
, rgb
[0].rgbGreen
, rgb
[0].rgbBlue
, rgb
[0].rgbReserved
,
590 rgb
[1].rgbRed
, rgb
[1].rgbGreen
, rgb
[1].rgbBlue
, rgb
[1].rgbReserved
);
592 SelectObject(hdcmem
, oldbm
);
593 test_dib_info(hdib
, bits
, &pbmi
->bmiHeader
);
596 pbmi
->bmiHeader
.biBitCount
= 4;
597 for (i
= 0; i
< 16; i
++) {
598 pbmi
->bmiColors
[i
].rgbRed
= i
;
599 pbmi
->bmiColors
[i
].rgbGreen
= 16-i
;
600 pbmi
->bmiColors
[i
].rgbBlue
= 0;
602 hdib
= CreateDIBSection(hdcmem
, pbmi
, DIB_RGB_COLORS
, (void**)&bits
, NULL
, 0);
603 ok(hdib
!= NULL
, "CreateDIBSection failed\n");
604 ok(GetObject(hdib
, sizeof(DIBSECTION
), &dibsec
) != 0, "GetObject failed for DIB Section\n");
605 ok(dibsec
.dsBmih
.biClrUsed
== 16,
606 "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec
.dsBmih
.biClrUsed
, 16);
607 test_dib_info(hdib
, bits
, &pbmi
->bmiHeader
);
610 pbmi
->bmiHeader
.biBitCount
= 8;
612 for (i
= 0; i
< 128; i
++) {
613 pbmi
->bmiColors
[i
].rgbRed
= 255 - i
* 2;
614 pbmi
->bmiColors
[i
].rgbGreen
= i
* 2;
615 pbmi
->bmiColors
[i
].rgbBlue
= 0;
616 pbmi
->bmiColors
[255 - i
].rgbRed
= 0;
617 pbmi
->bmiColors
[255 - i
].rgbGreen
= i
* 2;
618 pbmi
->bmiColors
[255 - i
].rgbBlue
= 255 - i
* 2;
620 hdib
= CreateDIBSection(hdcmem
, pbmi
, DIB_RGB_COLORS
, (void**)&bits
, NULL
, 0);
621 ok(hdib
!= NULL
, "CreateDIBSection failed\n");
622 ok(GetObject(hdib
, sizeof(DIBSECTION
), &dibsec
) != 0, "GetObject failed for DIB Section\n");
623 ok(dibsec
.dsBmih
.biClrUsed
== 256,
624 "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec
.dsBmih
.biClrUsed
, 256);
626 oldbm
= SelectObject(hdcmem
, hdib
);
628 for (i
= 0; i
< 256; i
++) {
629 test_color(hdcmem
, DIBINDEX(i
),
630 RGB(pbmi
->bmiColors
[i
].rgbRed
, pbmi
->bmiColors
[i
].rgbGreen
, pbmi
->bmiColors
[i
].rgbBlue
), 0, 0);
631 test_color(hdcmem
, PALETTERGB(pbmi
->bmiColors
[i
].rgbRed
, pbmi
->bmiColors
[i
].rgbGreen
, pbmi
->bmiColors
[i
].rgbBlue
),
632 RGB(pbmi
->bmiColors
[i
].rgbRed
, pbmi
->bmiColors
[i
].rgbGreen
, pbmi
->bmiColors
[i
].rgbBlue
), 0, 0);
635 SelectObject(hdcmem
, oldbm
);
636 test_dib_info(hdib
, bits
, &pbmi
->bmiHeader
);
639 pbmi
->bmiHeader
.biBitCount
= 1;
641 /* Now create a palette and a palette indexed dib section */
642 memset(plogpal
, 0, sizeof(logpalbuf
));
643 plogpal
->palVersion
= 0x300;
644 plogpal
->palNumEntries
= 2;
645 plogpal
->palPalEntry
[0].peRed
= 0xff;
646 plogpal
->palPalEntry
[0].peBlue
= 0xff;
647 plogpal
->palPalEntry
[1].peGreen
= 0xff;
649 index
= (WORD
*)pbmi
->bmiColors
;
652 hpal
= CreatePalette(plogpal
);
653 ok(hpal
!= NULL
, "CreatePalette failed\n");
654 oldpal
= SelectPalette(hdc
, hpal
, TRUE
);
655 hdib
= CreateDIBSection(hdc
, pbmi
, DIB_PAL_COLORS
, (void**)&bits
, NULL
, 0);
656 ok(hdib
!= NULL
, "CreateDIBSection failed\n");
657 ok(GetObject(hdib
, sizeof(DIBSECTION
), &dibsec
) != 0, "GetObject failed for DIB Section\n");
658 ok(dibsec
.dsBmih
.biClrUsed
== 2,
659 "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec
.dsBmih
.biClrUsed
, 2);
661 /* The colour table has already been grabbed from the dc, so we select back the
664 SelectPalette(hdc
, oldpal
, TRUE
);
665 oldbm
= SelectObject(hdcmem
, hdib
);
666 oldpal
= SelectPalette(hdcmem
, hpal
, TRUE
);
668 ret
= GetDIBColorTable(hdcmem
, 0, 2, rgb
);
669 ok(ret
== 2, "GetDIBColorTable returned %d\n", ret
);
670 ok(rgb
[0].rgbRed
== 0xff && rgb
[0].rgbBlue
== 0xff && rgb
[0].rgbGreen
== 0 &&
671 rgb
[1].rgbRed
== 0 && rgb
[1].rgbBlue
== 0 && rgb
[1].rgbGreen
== 0xff,
672 "GetDIBColorTable returns table 0: r%02x g%02x b%02x res%02x 1: r%02x g%02x b%02x res%02x\n",
673 rgb
[0].rgbRed
, rgb
[0].rgbGreen
, rgb
[0].rgbBlue
, rgb
[0].rgbReserved
,
674 rgb
[1].rgbRed
, rgb
[1].rgbGreen
, rgb
[1].rgbBlue
, rgb
[1].rgbReserved
);
676 c0
= RGB(plogpal
->palPalEntry
[0].peRed
, plogpal
->palPalEntry
[0].peGreen
, plogpal
->palPalEntry
[0].peBlue
);
677 c1
= RGB(plogpal
->palPalEntry
[1].peRed
, plogpal
->palPalEntry
[1].peGreen
, plogpal
->palPalEntry
[1].peBlue
);
679 test_color(hdcmem
, DIBINDEX(0), c0
, 0, 1);
680 test_color(hdcmem
, DIBINDEX(1), c1
, 0, 1);
681 test_color(hdcmem
, DIBINDEX(2), c0
, 1, 1);
682 test_color(hdcmem
, PALETTEINDEX(0), c0
, 0, 1);
683 test_color(hdcmem
, PALETTEINDEX(1), c1
, 0, 1);
684 test_color(hdcmem
, PALETTEINDEX(2), c0
, 1, 1);
685 test_color(hdcmem
, PALETTERGB(plogpal
->palPalEntry
[0].peRed
, plogpal
->palPalEntry
[0].peGreen
,
686 plogpal
->palPalEntry
[0].peBlue
), c0
, 1, 1);
687 test_color(hdcmem
, PALETTERGB(plogpal
->palPalEntry
[1].peRed
, plogpal
->palPalEntry
[1].peGreen
,
688 plogpal
->palPalEntry
[1].peBlue
), c1
, 1, 1);
689 test_color(hdcmem
, PALETTERGB(0, 0, 0), c1
, 1, 1);
690 test_color(hdcmem
, PALETTERGB(0xff, 0xff, 0xff), c0
, 1, 1);
691 test_color(hdcmem
, PALETTERGB(0, 0, 0xfe), c0
, 1, 1);
692 test_color(hdcmem
, PALETTERGB(0, 1, 0), c1
, 1, 1);
693 test_color(hdcmem
, PALETTERGB(0x3f, 0, 0x3f), c1
, 1, 1);
694 test_color(hdcmem
, PALETTERGB(0x40, 0, 0x40), c0
, 1, 1);
696 /* Bottom and 2nd row from top green, everything else magenta */
697 bits
[0] = bits
[1] = 0xff;
698 bits
[13 * 4] = bits
[13*4 + 1] = 0xff;
700 test_dib_info(hdib
, bits
, &pbmi
->bmiHeader
);
702 pbmi
->bmiHeader
.biBitCount
= 32;
704 hdib2
= CreateDIBSection(NULL
, pbmi
, DIB_RGB_COLORS
, (void **)&bits32
, NULL
, 0);
705 ok(hdib2
!= NULL
, "CreateDIBSection failed\n");
706 hdcmem2
= CreateCompatibleDC(hdc
);
707 oldbm2
= SelectObject(hdcmem2
, hdib2
);
709 BitBlt(hdcmem2
, 0, 0, 16,16, hdcmem
, 0, 0, SRCCOPY
);
711 ok(bits32
[0] == 0xff00, "lower left pixel is %08x\n", bits32
[0]);
712 ok(bits32
[17] == 0xff00ff, "bottom but one, left pixel is %08x\n", bits32
[17]);
714 SelectObject(hdcmem2
, oldbm2
);
715 test_dib_info(hdib2
, bits32
, &pbmi
->bmiHeader
);
718 SelectObject(hdcmem
, oldbm
);
719 SelectObject(hdcmem
, oldpal
);
724 pbmi
->bmiHeader
.biBitCount
= 8;
726 memset(plogpal
, 0, sizeof(logpalbuf
));
727 plogpal
->palVersion
= 0x300;
728 plogpal
->palNumEntries
= 256;
730 for (i
= 0; i
< 128; i
++) {
731 plogpal
->palPalEntry
[i
].peRed
= 255 - i
* 2;
732 plogpal
->palPalEntry
[i
].peBlue
= i
* 2;
733 plogpal
->palPalEntry
[i
].peGreen
= 0;
734 plogpal
->palPalEntry
[255 - i
].peRed
= 0;
735 plogpal
->palPalEntry
[255 - i
].peGreen
= i
* 2;
736 plogpal
->palPalEntry
[255 - i
].peBlue
= 255 - i
* 2;
739 index
= (WORD
*)pbmi
->bmiColors
;
740 for (i
= 0; i
< 256; i
++) {
744 hpal
= CreatePalette(plogpal
);
745 ok(hpal
!= NULL
, "CreatePalette failed\n");
746 oldpal
= SelectPalette(hdc
, hpal
, TRUE
);
747 hdib
= CreateDIBSection(hdc
, pbmi
, DIB_PAL_COLORS
, (void**)&bits
, NULL
, 0);
748 ok(hdib
!= NULL
, "CreateDIBSection failed\n");
749 ok(GetObject(hdib
, sizeof(DIBSECTION
), &dibsec
) != 0, "GetObject failed for DIB Section\n");
750 ok(dibsec
.dsBmih
.biClrUsed
== 256,
751 "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec
.dsBmih
.biClrUsed
, 256);
753 test_dib_info(hdib
, bits
, &pbmi
->bmiHeader
);
755 SelectPalette(hdc
, oldpal
, TRUE
);
756 oldbm
= SelectObject(hdcmem
, hdib
);
757 oldpal
= SelectPalette(hdcmem
, hpal
, TRUE
);
759 ret
= GetDIBColorTable(hdcmem
, 0, 256, rgb
);
760 ok(ret
== 256, "GetDIBColorTable returned %d\n", ret
);
761 for (i
= 0; i
< 256; i
++) {
762 ok(rgb
[i
].rgbRed
== plogpal
->palPalEntry
[i
].peRed
&&
763 rgb
[i
].rgbBlue
== plogpal
->palPalEntry
[i
].peBlue
&&
764 rgb
[i
].rgbGreen
== plogpal
->palPalEntry
[i
].peGreen
,
765 "GetDIBColorTable returns table %d: r%02x g%02x b%02x res%02x\n",
766 i
, rgb
[i
].rgbRed
, rgb
[i
].rgbGreen
, rgb
[i
].rgbBlue
, rgb
[i
].rgbReserved
);
769 for (i
= 0; i
< 256; i
++) {
770 test_color(hdcmem
, DIBINDEX(i
),
771 RGB(plogpal
->palPalEntry
[i
].peRed
, plogpal
->palPalEntry
[i
].peGreen
, plogpal
->palPalEntry
[i
].peBlue
), 0, 0);
772 test_color(hdcmem
, PALETTEINDEX(i
),
773 RGB(plogpal
->palPalEntry
[i
].peRed
, plogpal
->palPalEntry
[i
].peGreen
, plogpal
->palPalEntry
[i
].peBlue
), 0, 0);
774 test_color(hdcmem
, PALETTERGB(plogpal
->palPalEntry
[i
].peRed
, plogpal
->palPalEntry
[i
].peGreen
, plogpal
->palPalEntry
[i
].peBlue
),
775 RGB(plogpal
->palPalEntry
[i
].peRed
, plogpal
->palPalEntry
[i
].peGreen
, plogpal
->palPalEntry
[i
].peBlue
), 0, 0);
778 SelectPalette(hdcmem
, oldpal
, TRUE
);
779 SelectObject(hdcmem
, oldbm
);
788 static void test_mono_dibsection(void)
791 HBITMAP old_bm
, mono_ds
;
792 char bmibuf
[sizeof(BITMAPINFO
) + 256 * sizeof(RGBQUAD
)];
793 BITMAPINFO
*pbmi
= (BITMAPINFO
*)bmibuf
;
800 memdc
= CreateCompatibleDC(hdc
);
802 memset(pbmi
, 0, sizeof(bmibuf
));
803 pbmi
->bmiHeader
.biSize
= sizeof(pbmi
->bmiHeader
);
804 pbmi
->bmiHeader
.biHeight
= 10;
805 pbmi
->bmiHeader
.biWidth
= 10;
806 pbmi
->bmiHeader
.biBitCount
= 1;
807 pbmi
->bmiHeader
.biPlanes
= 1;
808 pbmi
->bmiHeader
.biCompression
= BI_RGB
;
809 pbmi
->bmiColors
[0].rgbRed
= 0xff;
810 pbmi
->bmiColors
[0].rgbGreen
= 0xff;
811 pbmi
->bmiColors
[0].rgbBlue
= 0xff;
812 pbmi
->bmiColors
[1].rgbRed
= 0x0;
813 pbmi
->bmiColors
[1].rgbGreen
= 0x0;
814 pbmi
->bmiColors
[1].rgbBlue
= 0x0;
817 * First dib section is 'inverted' ie color[0] is white, color[1] is black
820 mono_ds
= CreateDIBSection(hdc
, pbmi
, DIB_RGB_COLORS
, (void**)&ds_bits
, NULL
, 0);
821 ok(mono_ds
!= NULL
, "CreateDIBSection rets NULL\n");
822 old_bm
= SelectObject(memdc
, mono_ds
);
824 /* black border, white interior */
825 Rectangle(memdc
, 0, 0, 10, 10);
826 ok(ds_bits
[0] == 0xff, "out_bits %02x\n", ds_bits
[0]);
827 ok(ds_bits
[4] == 0x80, "out_bits %02x\n", ds_bits
[4]);
829 /* SetDIBitsToDevice with an inverted bmi -> inverted dib section */
831 memset(bits
, 0, sizeof(bits
));
834 SetDIBitsToDevice(memdc
, 0, 0, 10, 10, 0, 0, 0, 10, bits
, pbmi
, DIB_RGB_COLORS
);
835 ok(ds_bits
[0] == 0xaa, "out_bits %02x\n", ds_bits
[0]);
837 /* SetDIBitsToDevice with a normal bmi -> inverted dib section */
839 pbmi
->bmiColors
[0].rgbRed
= 0x0;
840 pbmi
->bmiColors
[0].rgbGreen
= 0x0;
841 pbmi
->bmiColors
[0].rgbBlue
= 0x0;
842 pbmi
->bmiColors
[1].rgbRed
= 0xff;
843 pbmi
->bmiColors
[1].rgbGreen
= 0xff;
844 pbmi
->bmiColors
[1].rgbBlue
= 0xff;
846 SetDIBitsToDevice(memdc
, 0, 0, 10, 10, 0, 0, 0, 10, bits
, pbmi
, DIB_RGB_COLORS
);
847 ok(ds_bits
[0] == 0x55, "out_bits %02x\n", ds_bits
[0]);
849 SelectObject(memdc
, old_bm
);
850 DeleteObject(mono_ds
);
853 * Next dib section is 'normal' ie color[0] is black, color[1] is white
856 pbmi
->bmiColors
[0].rgbRed
= 0x0;
857 pbmi
->bmiColors
[0].rgbGreen
= 0x0;
858 pbmi
->bmiColors
[0].rgbBlue
= 0x0;
859 pbmi
->bmiColors
[1].rgbRed
= 0xff;
860 pbmi
->bmiColors
[1].rgbGreen
= 0xff;
861 pbmi
->bmiColors
[1].rgbBlue
= 0xff;
863 mono_ds
= CreateDIBSection(hdc
, pbmi
, DIB_RGB_COLORS
, (void**)&ds_bits
, NULL
, 0);
864 ok(mono_ds
!= NULL
, "CreateDIBSection rets NULL\n");
865 old_bm
= SelectObject(memdc
, mono_ds
);
867 /* black border, white interior */
868 Rectangle(memdc
, 0, 0, 10, 10);
869 ok(ds_bits
[0] == 0x00, "out_bits %02x\n", ds_bits
[0]);
870 ok(ds_bits
[4] == 0x7f, "out_bits %02x\n", ds_bits
[4]);
872 /* SetDIBitsToDevice with a normal bmi -> normal dib section */
874 SetDIBitsToDevice(memdc
, 0, 0, 10, 10, 0, 0, 0, 10, bits
, pbmi
, DIB_RGB_COLORS
);
875 ok(ds_bits
[0] == 0xaa, "out_bits %02x\n", ds_bits
[0]);
877 /* SetDIBitsToDevice with a inverted bmi -> normal dib section */
879 pbmi
->bmiColors
[0].rgbRed
= 0xff;
880 pbmi
->bmiColors
[0].rgbGreen
= 0xff;
881 pbmi
->bmiColors
[0].rgbBlue
= 0xff;
882 pbmi
->bmiColors
[1].rgbRed
= 0x0;
883 pbmi
->bmiColors
[1].rgbGreen
= 0x0;
884 pbmi
->bmiColors
[1].rgbBlue
= 0x0;
886 SetDIBitsToDevice(memdc
, 0, 0, 10, 10, 0, 0, 0, 10, bits
, pbmi
, DIB_RGB_COLORS
);
887 ok(ds_bits
[0] == 0x55, "out_bits %02x\n", ds_bits
[0]);
890 * Take that 'normal' dibsection and change its colour table to an 'inverted' one
893 pbmi
->bmiColors
[0].rgbRed
= 0xff;
894 pbmi
->bmiColors
[0].rgbGreen
= 0xff;
895 pbmi
->bmiColors
[0].rgbBlue
= 0xff;
896 pbmi
->bmiColors
[1].rgbRed
= 0x0;
897 pbmi
->bmiColors
[1].rgbGreen
= 0x0;
898 pbmi
->bmiColors
[1].rgbBlue
= 0x0;
899 num
= SetDIBColorTable(memdc
, 0, 2, pbmi
->bmiColors
);
900 ok(num
== 2, "num = %d\n", num
);
902 /* black border, white interior */
903 Rectangle(memdc
, 0, 0, 10, 10);
905 ok(ds_bits
[0] == 0xff, "out_bits %02x\n", ds_bits
[0]);
906 ok(ds_bits
[4] == 0x80, "out_bits %02x\n", ds_bits
[4]);
908 /* SetDIBitsToDevice with an inverted bmi -> inverted dib section */
910 memset(bits
, 0, sizeof(bits
));
913 SetDIBitsToDevice(memdc
, 0, 0, 10, 10, 0, 0, 0, 10, bits
, pbmi
, DIB_RGB_COLORS
);
914 ok(ds_bits
[0] == 0xaa, "out_bits %02x\n", ds_bits
[0]);
916 /* SetDIBitsToDevice with a normal bmi -> inverted dib section */
918 pbmi
->bmiColors
[0].rgbRed
= 0x0;
919 pbmi
->bmiColors
[0].rgbGreen
= 0x0;
920 pbmi
->bmiColors
[0].rgbBlue
= 0x0;
921 pbmi
->bmiColors
[1].rgbRed
= 0xff;
922 pbmi
->bmiColors
[1].rgbGreen
= 0xff;
923 pbmi
->bmiColors
[1].rgbBlue
= 0xff;
925 SetDIBitsToDevice(memdc
, 0, 0, 10, 10, 0, 0, 0, 10, bits
, pbmi
, DIB_RGB_COLORS
);
926 ok(ds_bits
[0] == 0x55, "out_bits %02x\n", ds_bits
[0]);
928 SelectObject(memdc
, old_bm
);
929 DeleteObject(mono_ds
);
932 * Now a dib section with a strange colour map just for fun. This behaves just like an inverted one.
935 pbmi
->bmiColors
[0].rgbRed
= 0xff;
936 pbmi
->bmiColors
[0].rgbGreen
= 0x0;
937 pbmi
->bmiColors
[0].rgbBlue
= 0x0;
938 pbmi
->bmiColors
[1].rgbRed
= 0xfe;
939 pbmi
->bmiColors
[1].rgbGreen
= 0x0;
940 pbmi
->bmiColors
[1].rgbBlue
= 0x0;
942 mono_ds
= CreateDIBSection(hdc
, pbmi
, DIB_RGB_COLORS
, (void**)&ds_bits
, NULL
, 0);
943 ok(mono_ds
!= NULL
, "CreateDIBSection rets NULL\n");
944 old_bm
= SelectObject(memdc
, mono_ds
);
946 /* black border, white interior */
947 Rectangle(memdc
, 0, 0, 10, 10);
948 ok(ds_bits
[0] == 0xff, "out_bits %02x\n", ds_bits
[0]);
949 ok(ds_bits
[4] == 0x80, "out_bits %02x\n", ds_bits
[4]);
951 /* SetDIBitsToDevice with a normal bmi -> inverted dib section */
953 pbmi
->bmiColors
[0].rgbRed
= 0x0;
954 pbmi
->bmiColors
[0].rgbGreen
= 0x0;
955 pbmi
->bmiColors
[0].rgbBlue
= 0x0;
956 pbmi
->bmiColors
[1].rgbRed
= 0xff;
957 pbmi
->bmiColors
[1].rgbGreen
= 0xff;
958 pbmi
->bmiColors
[1].rgbBlue
= 0xff;
960 SetDIBitsToDevice(memdc
, 0, 0, 10, 10, 0, 0, 0, 10, bits
, pbmi
, DIB_RGB_COLORS
);
961 ok(ds_bits
[0] == 0x55, "out_bits %02x\n", ds_bits
[0]);
963 /* SetDIBitsToDevice with a inverted bmi -> inverted dib section */
965 pbmi
->bmiColors
[0].rgbRed
= 0xff;
966 pbmi
->bmiColors
[0].rgbGreen
= 0xff;
967 pbmi
->bmiColors
[0].rgbBlue
= 0xff;
968 pbmi
->bmiColors
[1].rgbRed
= 0x0;
969 pbmi
->bmiColors
[1].rgbGreen
= 0x0;
970 pbmi
->bmiColors
[1].rgbBlue
= 0x0;
972 SetDIBitsToDevice(memdc
, 0, 0, 10, 10, 0, 0, 0, 10, bits
, pbmi
, DIB_RGB_COLORS
);
973 ok(ds_bits
[0] == 0xaa, "out_bits %02x\n", ds_bits
[0]);
975 SelectObject(memdc
, old_bm
);
976 DeleteObject(mono_ds
);
982 static void test_bitmap(void)
984 char buf
[256], buf_cmp
[256];
985 HBITMAP hbmp
, hbmp_old
;
991 hdc
= CreateCompatibleDC(0);
994 SetLastError(0xdeadbeef);
995 hbmp
= CreateBitmap(0x7ffffff, 1, 1, 1, NULL
);
998 ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY
/* XP */ ||
999 GetLastError() == ERROR_INVALID_PARAMETER
/* Win2k */,
1000 "expected ERROR_NOT_ENOUGH_MEMORY, got %u\n", GetLastError());
1005 SetLastError(0xdeadbeef);
1006 hbmp
= CreateBitmap(0x7ffffff, 9, 1, 1, NULL
);
1009 ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY
/* XP */ ||
1010 GetLastError() == ERROR_INVALID_PARAMETER
/* Win2k */,
1011 "expected ERROR_NOT_ENOUGH_MEMORY, got %u\n", GetLastError());
1016 SetLastError(0xdeadbeef);
1017 hbmp
= CreateBitmap(0x7ffffff + 1, 1, 1, 1, NULL
);
1018 ok(!hbmp
, "CreateBitmap should fail\n");
1019 ok(GetLastError() == ERROR_INVALID_PARAMETER
,
1020 "expected ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1022 hbmp
= CreateBitmap(15, 15, 1, 1, NULL
);
1023 assert(hbmp
!= NULL
);
1025 ret
= GetObject(hbmp
, sizeof(bm
), &bm
);
1026 ok(ret
== sizeof(bm
), "wrong size %d\n", ret
);
1028 ok(bm
.bmType
== 0, "wrong bm.bmType %d\n", bm
.bmType
);
1029 ok(bm
.bmWidth
== 15, "wrong bm.bmWidth %d\n", bm
.bmWidth
);
1030 ok(bm
.bmHeight
== 15, "wrong bm.bmHeight %d\n", bm
.bmHeight
);
1031 ok(bm
.bmWidthBytes
== 2, "wrong bm.bmWidthBytes %d\n", bm
.bmWidthBytes
);
1032 ok(bm
.bmPlanes
== 1, "wrong bm.bmPlanes %d\n", bm
.bmPlanes
);
1033 ok(bm
.bmBitsPixel
== 1, "wrong bm.bmBitsPixel %d\n", bm
.bmBitsPixel
);
1034 ok(bm
.bmBits
== NULL
, "wrong bm.bmBits %p\n", bm
.bmBits
);
1036 assert(sizeof(buf
) >= bm
.bmWidthBytes
* bm
.bmHeight
);
1037 assert(sizeof(buf
) == sizeof(buf_cmp
));
1039 ret
= GetBitmapBits(hbmp
, 0, NULL
);
1040 ok(ret
== bm
.bmWidthBytes
* bm
.bmHeight
, "%d != %d\n", ret
, bm
.bmWidthBytes
* bm
.bmHeight
);
1042 memset(buf_cmp
, 0xAA, sizeof(buf_cmp
));
1043 memset(buf_cmp
, 0, bm
.bmWidthBytes
* bm
.bmHeight
);
1045 memset(buf
, 0xAA, sizeof(buf
));
1046 ret
= GetBitmapBits(hbmp
, sizeof(buf
), buf
);
1047 ok(ret
== bm
.bmWidthBytes
* bm
.bmHeight
, "%d != %d\n", ret
, bm
.bmWidthBytes
* bm
.bmHeight
);
1048 ok(!memcmp(buf
, buf_cmp
, sizeof(buf
)), "buffers do not match\n");
1050 hbmp_old
= SelectObject(hdc
, hbmp
);
1052 ret
= GetObject(hbmp
, sizeof(bm
), &bm
);
1053 ok(ret
== sizeof(bm
), "wrong size %d\n", ret
);
1055 ok(bm
.bmType
== 0, "wrong bm.bmType %d\n", bm
.bmType
);
1056 ok(bm
.bmWidth
== 15, "wrong bm.bmWidth %d\n", bm
.bmWidth
);
1057 ok(bm
.bmHeight
== 15, "wrong bm.bmHeight %d\n", bm
.bmHeight
);
1058 ok(bm
.bmWidthBytes
== 2, "wrong bm.bmWidthBytes %d\n", bm
.bmWidthBytes
);
1059 ok(bm
.bmPlanes
== 1, "wrong bm.bmPlanes %d\n", bm
.bmPlanes
);
1060 ok(bm
.bmBitsPixel
== 1, "wrong bm.bmBitsPixel %d\n", bm
.bmBitsPixel
);
1061 ok(bm
.bmBits
== NULL
, "wrong bm.bmBits %p\n", bm
.bmBits
);
1063 memset(buf
, 0xAA, sizeof(buf
));
1064 ret
= GetBitmapBits(hbmp
, sizeof(buf
), buf
);
1065 ok(ret
== bm
.bmWidthBytes
* bm
.bmHeight
, "%d != %d\n", ret
, bm
.bmWidthBytes
* bm
.bmHeight
);
1066 ok(!memcmp(buf
, buf_cmp
, sizeof(buf
)), "buffers do not match\n");
1068 hbmp_old
= SelectObject(hdc
, hbmp_old
);
1069 ok(hbmp_old
== hbmp
, "wrong old bitmap %p\n", hbmp_old
);
1071 /* test various buffer sizes for GetObject */
1072 ret
= GetObject(hbmp
, sizeof(*bma
) * 2, bma
);
1073 ok(ret
== sizeof(*bma
) || broken(ret
== sizeof(*bma
) * 2 /* Win9x */), "wrong size %d\n", ret
);
1075 ret
= GetObject(hbmp
, sizeof(bm
) / 2, &bm
);
1076 ok(ret
== 0 || broken(ret
== sizeof(bm
) / 2 /* Win9x */), "%d != 0\n", ret
);
1078 ret
= GetObject(hbmp
, 0, &bm
);
1079 ok(ret
== 0, "%d != 0\n", ret
);
1081 ret
= GetObject(hbmp
, 1, &bm
);
1082 ok(ret
== 0 || broken(ret
== 1 /* Win9x */), "%d != 0\n", ret
);
1088 static void test_bmBits(void)
1094 memset(bits
, 0, sizeof(bits
));
1095 hbmp
= CreateBitmap(2, 2, 1, 4, bits
);
1096 ok(hbmp
!= NULL
, "CreateBitmap failed\n");
1098 memset(&bmp
, 0xFF, sizeof(bmp
));
1099 ok(GetObject(hbmp
, sizeof(bmp
), &bmp
) == sizeof(bmp
),
1100 "GetObject failed or returned a wrong structure size\n");
1101 ok(!bmp
.bmBits
, "bmBits must be NULL for device-dependent bitmaps\n");
1106 static void test_GetDIBits_selected_DIB(UINT bpp
)
1120 /* Create a DIB section with a color table */
1122 info
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(BITMAPINFOHEADER
) + (1 << bpp
) * sizeof(RGBQUAD
));
1123 info2
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(BITMAPINFOHEADER
) + (1 << bpp
) * sizeof(RGBQUAD
));
1127 info
->bmiHeader
.biSize
= sizeof(info
->bmiHeader
);
1129 /* Choose width and height such that the row length (in bytes)
1130 is a multiple of 4 (makes things easier) */
1131 info
->bmiHeader
.biWidth
= 32;
1132 info
->bmiHeader
.biHeight
= 32;
1133 info
->bmiHeader
.biPlanes
= 1;
1134 info
->bmiHeader
.biBitCount
= bpp
;
1135 info
->bmiHeader
.biCompression
= BI_RGB
;
1137 for (i
=0; i
< (1u << bpp
); i
++)
1139 BYTE c
= i
* (1 << (8 - bpp
));
1140 info
->bmiColors
[i
].rgbRed
= c
;
1141 info
->bmiColors
[i
].rgbGreen
= c
;
1142 info
->bmiColors
[i
].rgbBlue
= c
;
1143 info
->bmiColors
[i
].rgbReserved
= 0;
1146 dib
= CreateDIBSection(NULL
, info
, DIB_RGB_COLORS
, &bits
, NULL
, 0);
1148 dib_size
= bpp
* (info
->bmiHeader
.biWidth
* info
->bmiHeader
.biHeight
) / 8;
1150 /* Set the bits of the DIB section */
1151 for (i
=0; i
< dib_size
; i
++)
1153 ((BYTE
*)bits
)[i
] = i
% 256;
1156 /* Select the DIB into a DC */
1157 dib_dc
= CreateCompatibleDC(NULL
);
1158 old_bmp
= (HBITMAP
) SelectObject(dib_dc
, dib
);
1159 dc
= CreateCompatibleDC(NULL
);
1160 bits2
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, dib_size
);
1163 /* Copy the DIB attributes but not the color table */
1164 memcpy(info2
, info
, sizeof(BITMAPINFOHEADER
));
1166 res
= GetDIBits(dc
, dib
, 0, info
->bmiHeader
.biHeight
, bits2
, info2
, DIB_RGB_COLORS
);
1167 ok(res
, "GetDIBits failed\n");
1169 /* Compare the color table and the bits */
1170 equalContents
= TRUE
;
1171 for (i
=0; i
< (1u << bpp
); i
++)
1173 if ((info
->bmiColors
[i
].rgbRed
!= info2
->bmiColors
[i
].rgbRed
)
1174 || (info
->bmiColors
[i
].rgbGreen
!= info2
->bmiColors
[i
].rgbGreen
)
1175 || (info
->bmiColors
[i
].rgbBlue
!= info2
->bmiColors
[i
].rgbBlue
)
1176 || (info
->bmiColors
[i
].rgbReserved
!= info2
->bmiColors
[i
].rgbReserved
))
1178 equalContents
= FALSE
;
1182 ok(equalContents
, "GetDIBits with DIB selected in DC: Invalid DIB color table\n");
1184 equalContents
= TRUE
;
1185 for (i
=0; i
< dib_size
/ sizeof(DWORD
); i
++)
1187 if (((DWORD
*)bits
)[i
] != ((DWORD
*)bits2
)[i
])
1189 equalContents
= FALSE
;
1193 ok(equalContents
, "GetDIBits with %d bpp DIB selected in DC: Invalid DIB bits\n",bpp
);
1195 HeapFree(GetProcessHeap(), 0, bits2
);
1198 SelectObject(dib_dc
, old_bmp
);
1202 HeapFree(GetProcessHeap(), 0, info2
);
1203 HeapFree(GetProcessHeap(), 0, info
);
1206 static void test_GetDIBits_selected_DDB(BOOL monochrome
)
1221 width
= height
= 16;
1223 /* Create a DDB (device-dependent bitmap) */
1227 ddb
= CreateBitmap(width
, height
, 1, 1, NULL
);
1231 HDC screen_dc
= GetDC(NULL
);
1232 bpp
= GetDeviceCaps(screen_dc
, BITSPIXEL
) * GetDeviceCaps(screen_dc
, PLANES
);
1233 ddb
= CreateCompatibleBitmap(screen_dc
, width
, height
);
1234 ReleaseDC(NULL
, screen_dc
);
1237 /* Set the pixels */
1238 ddb_dc
= CreateCompatibleDC(NULL
);
1239 old_bmp
= (HBITMAP
) SelectObject(ddb_dc
, ddb
);
1240 for (i
= 0; i
< width
; i
++)
1242 for (j
=0; j
< height
; j
++)
1244 BYTE c
= (i
* width
+ j
) % 256;
1245 SetPixelV(ddb_dc
, i
, j
, RGB(c
, c
, c
));
1248 SelectObject(ddb_dc
, old_bmp
);
1250 info
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(BITMAPINFOHEADER
) + 256 * sizeof(RGBQUAD
));
1251 info2
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, sizeof(BITMAPINFOHEADER
) + 256 * sizeof(RGBQUAD
));
1255 info
->bmiHeader
.biSize
= sizeof(info
->bmiHeader
);
1256 info
->bmiHeader
.biWidth
= width
;
1257 info
->bmiHeader
.biHeight
= height
;
1258 info
->bmiHeader
.biPlanes
= 1;
1259 info
->bmiHeader
.biBitCount
= bpp
;
1260 info
->bmiHeader
.biCompression
= BI_RGB
;
1262 dc
= CreateCompatibleDC(NULL
);
1264 /* Fill in biSizeImage */
1265 GetDIBits(dc
, ddb
, 0, height
, NULL
, info
, DIB_RGB_COLORS
);
1266 ok(info
->bmiHeader
.biSizeImage
!= 0, "GetDIBits failed to get the DIB attributes\n");
1268 bits
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, info
->bmiHeader
.biSizeImage
);
1269 bits2
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, info
->bmiHeader
.biSizeImage
);
1274 res
= GetDIBits(dc
, ddb
, 0, height
, bits
, info
, DIB_RGB_COLORS
);
1275 ok(res
, "GetDIBits failed\n");
1277 /* Copy the DIB attributes but not the color table */
1278 memcpy(info2
, info
, sizeof(BITMAPINFOHEADER
));
1280 /* Select the DDB into another DC */
1281 old_bmp
= (HBITMAP
) SelectObject(ddb_dc
, ddb
);
1284 res
= GetDIBits(dc
, ddb
, 0, height
, bits2
, info2
, DIB_RGB_COLORS
);
1285 ok(res
, "GetDIBits failed\n");
1287 /* Compare the color table and the bits */
1290 equalContents
= TRUE
;
1291 for (i
=0; i
< (1u << bpp
); i
++)
1293 if ((info
->bmiColors
[i
].rgbRed
!= info2
->bmiColors
[i
].rgbRed
)
1294 || (info
->bmiColors
[i
].rgbGreen
!= info2
->bmiColors
[i
].rgbGreen
)
1295 || (info
->bmiColors
[i
].rgbBlue
!= info2
->bmiColors
[i
].rgbBlue
)
1296 || (info
->bmiColors
[i
].rgbReserved
!= info2
->bmiColors
[i
].rgbReserved
))
1298 equalContents
= FALSE
;
1302 ok(equalContents
, "GetDIBits with DDB selected in DC: Got a different color table\n");
1305 equalContents
= TRUE
;
1306 for (i
=0; i
< info
->bmiHeader
.biSizeImage
/ sizeof(DWORD
); i
++)
1308 if (((DWORD
*)bits
)[i
] != ((DWORD
*)bits2
)[i
])
1310 equalContents
= FALSE
;
1313 ok(equalContents
, "GetDIBits with DDB selected in DC: Got different DIB bits\n");
1315 /* Test the palette */
1316 equalContents
= TRUE
;
1317 if (info2
->bmiHeader
.biBitCount
<= 8)
1319 WORD
*colors
= (WORD
*)info2
->bmiColors
;
1321 /* Get the palette indices */
1322 res
= GetDIBits(dc
, ddb
, 0, 0, NULL
, info2
, DIB_PAL_COLORS
);
1323 ok(res
, "GetDIBits failed\n");
1325 for (i
=0;i
< 1 << info
->bmiHeader
.biSizeImage
; i
++)
1329 equalContents
= FALSE
;
1335 ok(equalContents
, "GetDIBits with DDB selected in DC: non 1:1 palette indices\n");
1337 HeapFree(GetProcessHeap(), 0, bits2
);
1338 HeapFree(GetProcessHeap(), 0, bits
);
1341 SelectObject(ddb_dc
, old_bmp
);
1345 HeapFree(GetProcessHeap(), 0, info2
);
1346 HeapFree(GetProcessHeap(), 0, info
);
1349 static void test_GetDIBits(void)
1351 /* 2-bytes aligned 1-bit bitmap data: 16x16 */
1352 static const BYTE bmp_bits_1
[16 * 2] =
1354 0xff,0xff, 0,0, 0xff,0xff, 0,0,
1355 0xff,0xff, 0,0, 0xff,0xff, 0,0,
1356 0xff,0xff, 0,0, 0xff,0xff, 0,0,
1357 0xff,0xff, 0,0, 0xff,0xff, 0,0
1359 /* 4-bytes aligned 1-bit DIB data: 16x16 */
1360 static const BYTE dib_bits_1
[16 * 4] =
1362 0,0,0,0, 0xff,0xff,0,0, 0,0,0,0, 0xff,0xff,0,0,
1363 0,0,0,0, 0xff,0xff,0,0, 0,0,0,0, 0xff,0xff,0,0,
1364 0,0,0,0, 0xff,0xff,0,0, 0,0,0,0, 0xff,0xff,0,0,
1365 0,0,0,0, 0xff,0xff,0,0, 0,0,0,0, 0xff,0xff,0,0
1367 /* 2-bytes aligned 24-bit bitmap data: 16x16 */
1368 static const BYTE bmp_bits_24
[16 * 16*3] =
1370 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1371 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1372 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1373 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1374 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1375 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1376 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1377 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1378 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1379 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1380 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1381 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1382 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1383 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1384 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1385 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1386 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1387 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1388 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1389 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1390 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1391 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1392 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1393 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1394 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1395 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1396 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1397 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1398 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1399 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1400 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1401 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1403 /* 4-bytes aligned 24-bit DIB data: 16x16 */
1404 static const BYTE dib_bits_24
[16 * 16*3] =
1406 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1407 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1408 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1409 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1410 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1411 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1412 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1413 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1414 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1415 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1416 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1417 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1418 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1419 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1420 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1421 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1422 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1423 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1424 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1425 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1426 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1427 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1428 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1429 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1430 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1431 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1432 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1433 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1434 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1435 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1436 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1437 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
1442 int i
, bytes
, lines
;
1444 char bi_buf
[sizeof(BITMAPINFOHEADER
) + sizeof(RGBQUAD
) * 256];
1445 BITMAPINFO
*bi
= (BITMAPINFO
*)bi_buf
;
1449 /* 1-bit source bitmap data */
1450 hbmp
= CreateBitmap(16, 16, 1, 1, bmp_bits_1
);
1451 ok(hbmp
!= 0, "CreateBitmap failed\n");
1453 memset(&bm
, 0xAA, sizeof(bm
));
1454 bytes
= GetObject(hbmp
, sizeof(bm
), &bm
);
1455 ok(bytes
== sizeof(bm
), "GetObject returned %d\n", bytes
);
1456 ok(bm
.bmType
== 0, "wrong bmType %d\n", bm
.bmType
);
1457 ok(bm
.bmWidth
== 16, "wrong bmWidth %d\n", bm
.bmWidth
);
1458 ok(bm
.bmHeight
== 16, "wrong bmHeight %d\n", bm
.bmHeight
);
1459 ok(bm
.bmWidthBytes
== 2, "wrong bmWidthBytes %d\n", bm
.bmWidthBytes
);
1460 ok(bm
.bmPlanes
== 1, "wrong bmPlanes %u\n", bm
.bmPlanes
);
1461 ok(bm
.bmBitsPixel
== 1, "wrong bmBitsPixel %d\n", bm
.bmBitsPixel
);
1462 ok(!bm
.bmBits
, "wrong bmBits %p\n", bm
.bmBits
);
1464 bytes
= GetBitmapBits(hbmp
, 0, NULL
);
1465 ok(bytes
== sizeof(bmp_bits_1
), "expected 16*2 got %d bytes\n", bytes
);
1466 bytes
= GetBitmapBits(hbmp
, sizeof(buf
), buf
);
1467 ok(bytes
== sizeof(bmp_bits_1
), "expected 16*2 got %d bytes\n", bytes
);
1468 ok(!memcmp(buf
, bmp_bits_1
, sizeof(bmp_bits_1
)), "bitmap bits don't match\n");
1470 /* retrieve 1-bit DIB data */
1471 memset(bi
, 0, sizeof(*bi
));
1472 bi
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
1473 bi
->bmiHeader
.biWidth
= bm
.bmWidth
;
1474 bi
->bmiHeader
.biHeight
= bm
.bmHeight
;
1475 bi
->bmiHeader
.biPlanes
= 1;
1476 bi
->bmiHeader
.biBitCount
= 1;
1477 bi
->bmiHeader
.biCompression
= BI_RGB
;
1478 bi
->bmiHeader
.biSizeImage
= 0;
1479 memset(bi
->bmiColors
, 0xAA, sizeof(RGBQUAD
) * 256);
1480 SetLastError(0xdeadbeef);
1481 lines
= GetDIBits(0, hbmp
, 0, bm
.bmHeight
, buf
, bi
, DIB_RGB_COLORS
);
1482 ok(lines
== 0, "GetDIBits copied %d lines with hdc = 0\n", lines
);
1483 ok(GetLastError() == ERROR_INVALID_PARAMETER
, "wrong error %u\n", GetLastError());
1484 ok(bi
->bmiHeader
.biSizeImage
== 0, "expected 0, got %u\n", bi
->bmiHeader
.biSizeImage
);
1486 memset(buf
, 0xAA, sizeof(buf
));
1487 SetLastError(0xdeadbeef);
1488 lines
= GetDIBits(hdc
, hbmp
, 0, bm
.bmHeight
, buf
, bi
, DIB_RGB_COLORS
);
1489 ok(lines
== bm
.bmHeight
, "GetDIBits copied %d lines of %d, error %u\n",
1490 lines
, bm
.bmHeight
, GetLastError());
1491 ok(bi
->bmiHeader
.biSizeImage
== sizeof(dib_bits_1
), "expected 16*4, got %u\n", bi
->bmiHeader
.biSizeImage
);
1493 /* the color table consists of black and white */
1494 ok(bi
->bmiColors
[0].rgbRed
== 0 && bi
->bmiColors
[0].rgbGreen
== 0 &&
1495 bi
->bmiColors
[0].rgbBlue
== 0 && bi
->bmiColors
[0].rgbReserved
== 0,
1496 "expected bmiColors[0] 0,0,0,0 - got %x %x %x %x\n",
1497 bi
->bmiColors
[0].rgbRed
, bi
->bmiColors
[0].rgbGreen
,
1498 bi
->bmiColors
[0].rgbBlue
, bi
->bmiColors
[0].rgbReserved
);
1499 ok(bi
->bmiColors
[1].rgbRed
== 0xff && bi
->bmiColors
[1].rgbGreen
== 0xff &&
1500 bi
->bmiColors
[1].rgbBlue
== 0xff && bi
->bmiColors
[1].rgbReserved
== 0,
1501 "expected bmiColors[0] 0xff,0xff,0xff,0 - got %x %x %x %x\n",
1502 bi
->bmiColors
[1].rgbRed
, bi
->bmiColors
[1].rgbGreen
,
1503 bi
->bmiColors
[1].rgbBlue
, bi
->bmiColors
[1].rgbReserved
);
1504 for (i
= 2; i
< 256; i
++)
1506 ok(bi
->bmiColors
[i
].rgbRed
== 0xAA && bi
->bmiColors
[i
].rgbGreen
== 0xAA &&
1507 bi
->bmiColors
[i
].rgbBlue
== 0xAA && bi
->bmiColors
[i
].rgbReserved
== 0xAA,
1508 "expected bmiColors[%d] 0xAA,0xAA,0xAA,0xAA - got %x %x %x %x\n", i
,
1509 bi
->bmiColors
[i
].rgbRed
, bi
->bmiColors
[i
].rgbGreen
,
1510 bi
->bmiColors
[i
].rgbBlue
, bi
->bmiColors
[i
].rgbReserved
);
1513 /* returned bits are DWORD aligned and upside down */
1515 ok(!memcmp(buf
, dib_bits_1
, sizeof(dib_bits_1
)), "DIB bits don't match\n");
1517 /* Test the palette indices */
1518 memset(bi
->bmiColors
, 0xAA, sizeof(RGBQUAD
) * 256);
1519 SetLastError(0xdeadbeef);
1520 lines
= GetDIBits(hdc
, hbmp
, 0, 0, NULL
, bi
, DIB_PAL_COLORS
);
1522 ok(((WORD
*)bi
->bmiColors
)[0] == 0, "Color 0 is %d\n", ((WORD
*)bi
->bmiColors
)[0]);
1523 ok(((WORD
*)bi
->bmiColors
)[1] == 1, "Color 1 is %d\n", ((WORD
*)bi
->bmiColors
)[1]);
1524 for (i
= 2; i
< 256; i
++)
1525 ok(((WORD
*)bi
->bmiColors
)[i
] == 0xAAAA, "Color %d is %d\n", i
, ((WORD
*)bi
->bmiColors
)[1]);
1527 /* retrieve 24-bit DIB data */
1528 memset(bi
, 0, sizeof(*bi
));
1529 bi
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
1530 bi
->bmiHeader
.biWidth
= bm
.bmWidth
;
1531 bi
->bmiHeader
.biHeight
= bm
.bmHeight
;
1532 bi
->bmiHeader
.biPlanes
= 1;
1533 bi
->bmiHeader
.biBitCount
= 24;
1534 bi
->bmiHeader
.biCompression
= BI_RGB
;
1535 bi
->bmiHeader
.biSizeImage
= 0;
1536 memset(bi
->bmiColors
, 0xAA, sizeof(RGBQUAD
) * 256);
1537 memset(buf
, 0xAA, sizeof(buf
));
1538 SetLastError(0xdeadbeef);
1539 lines
= GetDIBits(hdc
, hbmp
, 0, bm
.bmHeight
, buf
, bi
, DIB_RGB_COLORS
);
1540 ok(lines
== bm
.bmHeight
, "GetDIBits copied %d lines of %d, error %u\n",
1541 lines
, bm
.bmHeight
, GetLastError());
1542 ok(bi
->bmiHeader
.biSizeImage
== sizeof(dib_bits_24
), "expected 16*16*3, got %u\n", bi
->bmiHeader
.biSizeImage
);
1544 /* the color table doesn't exist for 24-bit images */
1545 for (i
= 0; i
< 256; i
++)
1547 ok(bi
->bmiColors
[i
].rgbRed
== 0xAA && bi
->bmiColors
[i
].rgbGreen
== 0xAA &&
1548 bi
->bmiColors
[i
].rgbBlue
== 0xAA && bi
->bmiColors
[i
].rgbReserved
== 0xAA,
1549 "expected bmiColors[%d] 0xAA,0xAA,0xAA,0xAA - got %x %x %x %x\n", i
,
1550 bi
->bmiColors
[i
].rgbRed
, bi
->bmiColors
[i
].rgbGreen
,
1551 bi
->bmiColors
[i
].rgbBlue
, bi
->bmiColors
[i
].rgbReserved
);
1554 /* returned bits are DWORD aligned and upside down */
1556 ok(!memcmp(buf
, dib_bits_24
, sizeof(dib_bits_24
)), "DIB bits don't match\n");
1559 /* 24-bit source bitmap data */
1560 hbmp
= CreateCompatibleBitmap(hdc
, 16, 16);
1561 ok(hbmp
!= 0, "CreateBitmap failed\n");
1562 SetLastError(0xdeadbeef);
1563 bi
->bmiHeader
.biHeight
= -bm
.bmHeight
; /* indicate bottom-up data */
1564 lines
= SetDIBits(hdc
, hbmp
, 0, bm
.bmHeight
, bmp_bits_24
, bi
, DIB_RGB_COLORS
);
1565 ok(lines
== bm
.bmHeight
, "SetDIBits copied %d lines of %d, error %u\n",
1566 lines
, bm
.bmHeight
, GetLastError());
1568 memset(&bm
, 0xAA, sizeof(bm
));
1569 bytes
= GetObject(hbmp
, sizeof(bm
), &bm
);
1570 ok(bytes
== sizeof(bm
), "GetObject returned %d\n", bytes
);
1571 ok(bm
.bmType
== 0, "wrong bmType %d\n", bm
.bmType
);
1572 ok(bm
.bmWidth
== 16, "wrong bmWidth %d\n", bm
.bmWidth
);
1573 ok(bm
.bmHeight
== 16, "wrong bmHeight %d\n", bm
.bmHeight
);
1574 ok(bm
.bmWidthBytes
== BITMAP_GetWidthBytes(bm
.bmWidth
, bm
.bmBitsPixel
), "wrong bmWidthBytes %d\n", bm
.bmWidthBytes
);
1575 ok(bm
.bmPlanes
== GetDeviceCaps(hdc
, PLANES
), "wrong bmPlanes %u\n", bm
.bmPlanes
);
1576 ok(bm
.bmBitsPixel
== GetDeviceCaps(hdc
, BITSPIXEL
), "wrong bmBitsPixel %d\n", bm
.bmBitsPixel
);
1577 ok(!bm
.bmBits
, "wrong bmBits %p\n", bm
.bmBits
);
1579 bytes
= GetBitmapBits(hbmp
, 0, NULL
);
1580 ok(bytes
== bm
.bmWidthBytes
* bm
.bmHeight
, "expected %d got %d bytes\n",
1581 bm
.bmWidthBytes
* bm
.bmHeight
, bytes
);
1582 bytes
= GetBitmapBits(hbmp
, sizeof(buf
), buf
);
1583 ok(bytes
== bm
.bmWidthBytes
* bm
.bmHeight
, "expected %d got %d bytes\n",
1584 bm
.bmWidthBytes
* bm
.bmHeight
, bytes
);
1586 /* retrieve 1-bit DIB data */
1587 memset(bi
, 0, sizeof(*bi
));
1588 bi
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
1589 bi
->bmiHeader
.biWidth
= bm
.bmWidth
;
1590 bi
->bmiHeader
.biHeight
= bm
.bmHeight
;
1591 bi
->bmiHeader
.biPlanes
= 1;
1592 bi
->bmiHeader
.biBitCount
= 1;
1593 bi
->bmiHeader
.biCompression
= BI_RGB
;
1594 bi
->bmiHeader
.biSizeImage
= 0;
1595 memset(bi
->bmiColors
, 0xAA, sizeof(RGBQUAD
) * 256);
1596 memset(buf
, 0xAA, sizeof(buf
));
1597 SetLastError(0xdeadbeef);
1598 lines
= GetDIBits(hdc
, hbmp
, 0, bm
.bmHeight
, buf
, bi
, DIB_RGB_COLORS
);
1599 ok(lines
== bm
.bmHeight
, "GetDIBits copied %d lines of %d, error %u\n",
1600 lines
, bm
.bmHeight
, GetLastError());
1601 ok(bi
->bmiHeader
.biSizeImage
== sizeof(dib_bits_1
), "expected 16*4, got %u\n", bi
->bmiHeader
.biSizeImage
);
1603 /* the color table consists of black and white */
1604 ok(bi
->bmiColors
[0].rgbRed
== 0 && bi
->bmiColors
[0].rgbGreen
== 0 &&
1605 bi
->bmiColors
[0].rgbBlue
== 0 && bi
->bmiColors
[0].rgbReserved
== 0,
1606 "expected bmiColors[0] 0,0,0,0 - got %x %x %x %x\n",
1607 bi
->bmiColors
[0].rgbRed
, bi
->bmiColors
[0].rgbGreen
,
1608 bi
->bmiColors
[0].rgbBlue
, bi
->bmiColors
[0].rgbReserved
);
1609 ok(bi
->bmiColors
[1].rgbRed
== 0xff && bi
->bmiColors
[1].rgbGreen
== 0xff &&
1610 bi
->bmiColors
[1].rgbBlue
== 0xff && bi
->bmiColors
[1].rgbReserved
== 0,
1611 "expected bmiColors[0] 0xff,0xff,0xff,0 - got %x %x %x %x\n",
1612 bi
->bmiColors
[1].rgbRed
, bi
->bmiColors
[1].rgbGreen
,
1613 bi
->bmiColors
[1].rgbBlue
, bi
->bmiColors
[1].rgbReserved
);
1614 for (i
= 2; i
< 256; i
++)
1616 ok(bi
->bmiColors
[i
].rgbRed
== 0xAA && bi
->bmiColors
[i
].rgbGreen
== 0xAA &&
1617 bi
->bmiColors
[i
].rgbBlue
== 0xAA && bi
->bmiColors
[i
].rgbReserved
== 0xAA,
1618 "expected bmiColors[%d] 0xAA,0xAA,0xAA,0xAA - got %x %x %x %x\n", i
,
1619 bi
->bmiColors
[i
].rgbRed
, bi
->bmiColors
[i
].rgbGreen
,
1620 bi
->bmiColors
[i
].rgbBlue
, bi
->bmiColors
[i
].rgbReserved
);
1623 /* returned bits are DWORD aligned and upside down */
1625 ok(!memcmp(buf
, dib_bits_1
, sizeof(dib_bits_1
)), "DIB bits don't match\n");
1627 /* Test the palette indices */
1628 memset(bi
->bmiColors
, 0xAA, sizeof(RGBQUAD
) * 256);
1629 SetLastError(0xdeadbeef);
1630 lines
= GetDIBits(hdc
, hbmp
, 0, 0, NULL
, bi
, DIB_PAL_COLORS
);
1632 ok(((WORD
*)bi
->bmiColors
)[0] == 0, "Color 0 is %d\n", ((WORD
*)bi
->bmiColors
)[0]);
1633 ok(((WORD
*)bi
->bmiColors
)[1] == 1, "Color 1 is %d\n", ((WORD
*)bi
->bmiColors
)[1]);
1634 for (i
= 2; i
< 256; i
++)
1635 ok(((WORD
*)bi
->bmiColors
)[i
] == 0xAAAA, "Color %d is %d\n", i
, ((WORD
*)bi
->bmiColors
)[i
]);
1637 /* retrieve 24-bit DIB data */
1638 memset(bi
, 0, sizeof(*bi
));
1639 bi
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
1640 bi
->bmiHeader
.biWidth
= bm
.bmWidth
;
1641 bi
->bmiHeader
.biHeight
= bm
.bmHeight
;
1642 bi
->bmiHeader
.biPlanes
= 1;
1643 bi
->bmiHeader
.biBitCount
= 24;
1644 bi
->bmiHeader
.biCompression
= BI_RGB
;
1645 bi
->bmiHeader
.biSizeImage
= 0;
1646 memset(bi
->bmiColors
, 0xAA, sizeof(RGBQUAD
) * 256);
1647 memset(buf
, 0xAA, sizeof(buf
));
1648 SetLastError(0xdeadbeef);
1649 lines
= GetDIBits(hdc
, hbmp
, 0, bm
.bmHeight
, buf
, bi
, DIB_RGB_COLORS
);
1650 ok(lines
== bm
.bmHeight
, "GetDIBits copied %d lines of %d, error %u\n",
1651 lines
, bm
.bmHeight
, GetLastError());
1652 ok(bi
->bmiHeader
.biSizeImage
== sizeof(dib_bits_24
), "expected 16*16*3, got %u\n", bi
->bmiHeader
.biSizeImage
);
1654 /* the color table doesn't exist for 24-bit images */
1655 for (i
= 0; i
< 256; i
++)
1657 ok(bi
->bmiColors
[i
].rgbRed
== 0xAA && bi
->bmiColors
[i
].rgbGreen
== 0xAA &&
1658 bi
->bmiColors
[i
].rgbBlue
== 0xAA && bi
->bmiColors
[i
].rgbReserved
== 0xAA,
1659 "expected bmiColors[%d] 0xAA,0xAA,0xAA,0xAA - got %x %x %x %x\n", i
,
1660 bi
->bmiColors
[i
].rgbRed
, bi
->bmiColors
[i
].rgbGreen
,
1661 bi
->bmiColors
[i
].rgbBlue
, bi
->bmiColors
[i
].rgbReserved
);
1664 /* returned bits are DWORD aligned and upside down */
1665 ok(!memcmp(buf
, dib_bits_24
, sizeof(dib_bits_24
)), "DIB bits don't match\n");
1671 static void test_GetDIBits_BI_BITFIELDS(void)
1673 /* Try a screen resolution detection technique
1674 * from the September 1999 issue of Windows Developer's Journal
1675 * which seems to be in widespread use.
1676 * http://www.lesher.ws/highcolor.html
1677 * http://www.lesher.ws/vidfmt.c
1678 * It hinges on being able to retrieve the bitmaps
1679 * for the three primary colors in non-paletted 16 bit mode.
1681 char dibinfo_buf
[sizeof(BITMAPINFOHEADER
) + 256 * sizeof(RGBQUAD
)];
1683 LPBITMAPINFO dibinfo
= (LPBITMAPINFO
) dibinfo_buf
;
1688 memset(dibinfo
, 0, sizeof(dibinfo_buf
));
1689 dibinfo
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
1692 ok(hdc
!= NULL
, "GetDC failed?\n");
1693 hbm
= CreateCompatibleBitmap(hdc
, 1, 1);
1694 ok(hbm
!= NULL
, "CreateCompatibleBitmap failed?\n");
1696 /* Call GetDIBits to fill in bmiHeader. */
1697 ret
= GetDIBits(hdc
, hbm
, 0, 1, NULL
, dibinfo
, DIB_RGB_COLORS
);
1698 ok(ret
== 1, "GetDIBits failed\n");
1699 if (dibinfo
->bmiHeader
.biBitCount
> 8)
1701 DWORD
*bitmasks
= (DWORD
*)dibinfo
->bmiColors
;
1703 ok( dibinfo
->bmiHeader
.biCompression
== BI_BITFIELDS
,
1704 "compression is %u\n", dibinfo
->bmiHeader
.biCompression
);
1706 ok( !bitmasks
[0], "red mask is set\n" );
1707 ok( !bitmasks
[1], "green mask is set\n" );
1708 ok( !bitmasks
[2], "blue mask is set\n" );
1710 /* test with NULL bits pointer and correct bpp */
1711 dibinfo
->bmiHeader
.biSizeImage
= 0xdeadbeef;
1712 ret
= GetDIBits(hdc
, hbm
, 0, 1, NULL
, dibinfo
, DIB_RGB_COLORS
);
1713 ok(ret
== 1, "GetDIBits failed\n");
1715 ok( bitmasks
[0] != 0, "red mask is not set\n" );
1716 ok( bitmasks
[1] != 0, "green mask is not set\n" );
1717 ok( bitmasks
[2] != 0, "blue mask is not set\n" );
1718 ok( dibinfo
->bmiHeader
.biSizeImage
!= 0xdeadbeef, "size image not set\n" );
1720 /* test with valid bits pointer */
1721 memset(dibinfo
, 0, sizeof(dibinfo_buf
));
1722 dibinfo
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
1723 ret
= GetDIBits(hdc
, hbm
, 0, 1, NULL
, dibinfo
, DIB_RGB_COLORS
);
1724 ok(ret
== 1, "GetDIBits failed ret %u err %u\n",ret
,GetLastError());
1725 dibinfo
->bmiHeader
.biSizeImage
= 0xdeadbeef;
1726 ret
= GetDIBits(hdc
, hbm
, 0, 1, bits
, dibinfo
, DIB_RGB_COLORS
);
1727 ok(ret
== 1, "GetDIBits failed ret %u err %u\n",ret
,GetLastError());
1729 ok( bitmasks
[0] != 0, "red mask is not set\n" );
1730 ok( bitmasks
[1] != 0, "green mask is not set\n" );
1731 ok( bitmasks
[2] != 0, "blue mask is not set\n" );
1732 ok( dibinfo
->bmiHeader
.biSizeImage
!= 0xdeadbeef, "size image not set\n" );
1734 /* now with bits and 0 lines */
1735 memset(dibinfo
, 0, sizeof(dibinfo_buf
));
1736 dibinfo
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
1737 dibinfo
->bmiHeader
.biSizeImage
= 0xdeadbeef;
1738 ret
= GetDIBits(hdc
, hbm
, 0, 0, bits
, dibinfo
, DIB_RGB_COLORS
);
1740 ok( !bitmasks
[0], "red mask is set\n" );
1741 ok( !bitmasks
[1], "green mask is set\n" );
1742 ok( !bitmasks
[2], "blue mask is set\n" );
1743 ok( dibinfo
->bmiHeader
.biSizeImage
!= 0xdeadbeef, "size image not set\n" );
1745 memset(bitmasks
, 0, 3*sizeof(DWORD
));
1746 dibinfo
->bmiHeader
.biSizeImage
= 0xdeadbeef;
1747 ret
= GetDIBits(hdc
, hbm
, 0, 0, bits
, dibinfo
, DIB_RGB_COLORS
);
1748 ok(ret
== 1, "GetDIBits failed ret %u err %u\n",ret
,GetLastError());
1750 ok( bitmasks
[0] != 0, "red mask is not set\n" );
1751 ok( bitmasks
[1] != 0, "green mask is not set\n" );
1752 ok( bitmasks
[2] != 0, "blue mask is not set\n" );
1753 ok( dibinfo
->bmiHeader
.biSizeImage
!= 0xdeadbeef, "size image not set\n" );
1755 else skip("not in 16 bpp BI_BITFIELDS mode, skipping that test\n");
1758 ReleaseDC(NULL
, hdc
);
1761 static void test_select_object(void)
1764 HBITMAP hbm
, hbm_old
;
1766 DWORD depths
[] = {8, 15, 16, 24, 32};
1771 ok(hdc
!= 0, "GetDC(0) failed\n");
1772 hbm
= CreateCompatibleBitmap(hdc
, 10, 10);
1773 ok(hbm
!= 0, "CreateCompatibleBitmap failed\n");
1775 hbm_old
= SelectObject(hdc
, hbm
);
1776 ok(hbm_old
== 0, "SelectObject should fail\n");
1781 hdc
= CreateCompatibleDC(0);
1782 ok(hdc
!= 0, "GetDC(0) failed\n");
1783 hbm
= CreateCompatibleBitmap(hdc
, 10, 10);
1784 ok(hbm
!= 0, "CreateCompatibleBitmap failed\n");
1786 hbm_old
= SelectObject(hdc
, hbm
);
1787 ok(hbm_old
!= 0, "SelectObject failed\n");
1788 hbm_old
= SelectObject(hdc
, hbm_old
);
1789 ok(hbm_old
== hbm
, "SelectObject failed\n");
1793 /* test an 1-bpp bitmap */
1794 planes
= GetDeviceCaps(hdc
, PLANES
);
1797 hbm
= CreateBitmap(10, 10, planes
, bpp
, NULL
);
1798 ok(hbm
!= 0, "CreateBitmap failed\n");
1800 hbm_old
= SelectObject(hdc
, hbm
);
1801 ok(hbm_old
!= 0, "SelectObject failed\n");
1802 hbm_old
= SelectObject(hdc
, hbm_old
);
1803 ok(hbm_old
== hbm
, "SelectObject failed\n");
1807 for(i
= 0; i
< sizeof(depths
)/sizeof(depths
[0]); i
++) {
1808 /* test a color bitmap to dc bpp matching */
1809 planes
= GetDeviceCaps(hdc
, PLANES
);
1810 bpp
= GetDeviceCaps(hdc
, BITSPIXEL
);
1812 hbm
= CreateBitmap(10, 10, planes
, depths
[i
], NULL
);
1813 ok(hbm
!= 0, "CreateBitmap failed\n");
1815 hbm_old
= SelectObject(hdc
, hbm
);
1816 if(depths
[i
] == bpp
||
1817 (bpp
== 16 && depths
[i
] == 15) /* 16 and 15 bpp are compatible */
1819 ok(hbm_old
!= 0, "SelectObject failed, BITSPIXEL: %d, created depth: %d\n", bpp
, depths
[i
]);
1820 SelectObject(hdc
, hbm_old
);
1822 ok(hbm_old
== 0, "SelectObject should fail. BITSPIXELS: %d, created depth: %d\n", bpp
, depths
[i
]);
1825 memset(&bm
, 0xAA, sizeof(bm
));
1826 bytes
= GetObject(hbm
, sizeof(bm
), &bm
);
1827 ok(bytes
== sizeof(bm
), "GetObject returned %d\n", bytes
);
1828 ok(bm
.bmType
== 0, "wrong bmType %d\n", bm
.bmType
);
1829 ok(bm
.bmWidth
== 10, "wrong bmWidth %d\n", bm
.bmWidth
);
1830 ok(bm
.bmHeight
== 10, "wrong bmHeight %d\n", bm
.bmHeight
);
1831 ok(bm
.bmWidthBytes
== BITMAP_GetWidthBytes(bm
.bmWidth
, bm
.bmBitsPixel
), "wrong bmWidthBytes %d\n", bm
.bmWidthBytes
);
1832 ok(bm
.bmPlanes
== planes
, "wrong bmPlanes %u\n", bm
.bmPlanes
);
1833 if(depths
[i
] == 15) {
1834 ok(bm
.bmBitsPixel
== 16, "wrong bmBitsPixel %d(15 bpp special)\n", bm
.bmBitsPixel
);
1836 ok(bm
.bmBitsPixel
== depths
[i
], "wrong bmBitsPixel %d\n", bm
.bmBitsPixel
);
1838 ok(!bm
.bmBits
, "wrong bmBits %p\n", bm
.bmBits
);
1846 static void test_mono_1x1_bmp_dbg(HBITMAP hbmp
, int line
)
1851 ret
= GetObjectType(hbmp
);
1852 ok_(__FILE__
, line
)(ret
== OBJ_BITMAP
, "the object %p is not bitmap\n", hbmp
);
1854 ret
= GetObject(hbmp
, 0, 0);
1855 ok_(__FILE__
, line
)(ret
== sizeof(BITMAP
) /* XP */ ||
1856 ret
== sizeof(DIBSECTION
) /* Win9x */, "object size %d\n", ret
);
1858 memset(&bm
, 0xDA, sizeof(bm
));
1859 SetLastError(0xdeadbeef);
1860 ret
= GetObject(hbmp
, sizeof(bm
), &bm
);
1861 if (!ret
) /* XP, only for curObj2 */ return;
1862 ok_(__FILE__
, line
)(ret
== sizeof(BITMAP
) ||
1863 ret
== sizeof(DIBSECTION
) /* Win9x, only for curObj2 */,
1864 "GetObject returned %d, error %u\n", ret
, GetLastError());
1865 ok_(__FILE__
, line
)(bm
.bmType
== 0, "wrong bmType, expected 0 got %d\n", bm
.bmType
);
1866 ok_(__FILE__
, line
)(bm
.bmWidth
== 1, "wrong bmWidth, expected 1 got %d\n", bm
.bmWidth
);
1867 ok_(__FILE__
, line
)(bm
.bmHeight
== 1, "wrong bmHeight, expected 1 got %d\n", bm
.bmHeight
);
1868 ok_(__FILE__
, line
)(bm
.bmWidthBytes
== 2, "wrong bmWidthBytes, expected 2 got %d\n", bm
.bmWidthBytes
);
1869 ok_(__FILE__
, line
)(bm
.bmPlanes
== 1, "wrong bmPlanes, expected 1 got %u\n", bm
.bmPlanes
);
1870 ok_(__FILE__
, line
)(bm
.bmBitsPixel
== 1, "wrong bmBitsPixel, expected 1 got %d\n", bm
.bmBitsPixel
);
1871 ok_(__FILE__
, line
)(!bm
.bmBits
, "wrong bmBits %p\n", bm
.bmBits
);
1874 #define test_mono_1x1_bmp(a) test_mono_1x1_bmp_dbg((a), __LINE__)
1876 static void test_CreateBitmap(void)
1879 HDC screenDC
= GetDC(0);
1880 HDC hdc
= CreateCompatibleDC(screenDC
);
1883 /* all of these are the stock monochrome bitmap */
1884 HBITMAP bm
= CreateCompatibleBitmap(hdc
, 0, 0);
1885 HBITMAP bm1
= CreateCompatibleBitmap(screenDC
, 0, 0);
1886 HBITMAP bm4
= CreateBitmap(0, 1, 0, 0, 0);
1887 HBITMAP bm5
= CreateDiscardableBitmap(hdc
, 0, 0);
1888 HBITMAP curObj1
= (HBITMAP
)GetCurrentObject(hdc
, OBJ_BITMAP
);
1889 HBITMAP curObj2
= (HBITMAP
)GetCurrentObject(screenDC
, OBJ_BITMAP
);
1891 /* these 2 are not the stock monochrome bitmap */
1892 HBITMAP bm2
= CreateCompatibleBitmap(hdc
, 1, 1);
1893 HBITMAP bm3
= CreateBitmap(1, 1, 1, 1, 0);
1895 HBITMAP old1
= (HBITMAP
)SelectObject(hdc
, bm2
);
1896 HBITMAP old2
= (HBITMAP
)SelectObject(screenDC
, bm3
);
1897 SelectObject(hdc
, old1
);
1898 SelectObject(screenDC
, old2
);
1900 ok(bm
== bm1
&& bm
== bm4
&& bm
== bm5
&& bm
== curObj1
&& bm
== old1
,
1901 "0: %p, 1: %p, 4: %p, 5: %p, curObj1 %p, old1 %p\n",
1902 bm
, bm1
, bm4
, bm5
, curObj1
, old1
);
1903 ok(bm
!= bm2
&& bm
!= bm3
, "0: %p, 2: %p, 3: %p\n", bm
, bm2
, bm3
);
1904 ok(bm
!= curObj2
/* XP */ || bm
== curObj2
/* Win9x */,
1905 "0: %p, curObj2 %p\n", bm
, curObj2
);
1906 ok(old2
== 0, "old2 %p\n", old2
);
1908 test_mono_1x1_bmp(bm
);
1909 test_mono_1x1_bmp(bm1
);
1910 test_mono_1x1_bmp(bm2
);
1911 test_mono_1x1_bmp(bm3
);
1912 test_mono_1x1_bmp(bm4
);
1913 test_mono_1x1_bmp(bm5
);
1914 test_mono_1x1_bmp(old1
);
1915 test_mono_1x1_bmp(curObj1
);
1916 test_mono_1x1_bmp(curObj2
);
1926 ReleaseDC(0, screenDC
);
1928 /* show that Windows ignores the provided bm.bmWidthBytes */
1932 bmp
.bmWidthBytes
= 28;
1934 bmp
.bmBitsPixel
= 1;
1936 bm
= CreateBitmapIndirect(&bmp
);
1937 ok(bm
!= 0, "CreateBitmapIndirect error %u\n", GetLastError());
1938 test_mono_1x1_bmp(bm
);
1941 /* Test how the bmBitsPixel field is treated */
1942 for(i
= 1; i
<= 33; i
++) {
1946 bmp
.bmWidthBytes
= 28;
1948 bmp
.bmBitsPixel
= i
;
1950 bm
= CreateBitmapIndirect(&bmp
);
1952 DWORD error
= GetLastError();
1953 ok(bm
== 0, "CreateBitmapIndirect for %d bpp succeeded\n", i
);
1954 ok(error
== ERROR_INVALID_PARAMETER
, "Got error %d, expected ERROR_INVALID_PARAMETER\n", error
);
1957 ok(bm
!= 0, "CreateBitmapIndirect error %u\n", GetLastError());
1958 GetObject(bm
, sizeof(bmp
), &bmp
);
1965 } else if(i
<= 16) {
1967 } else if(i
<= 24) {
1969 } else if(i
<= 32) {
1972 ok(bmp
.bmBitsPixel
== expect
, "CreateBitmapIndirect for a %d bpp bitmap created a %d bpp bitmap, expected %d\n",
1973 i
, bmp
.bmBitsPixel
, expect
);
1978 static void test_bitmapinfoheadersize(void)
1985 memset(&bmi
, 0, sizeof(BITMAPINFO
));
1986 bmi
.bmiHeader
.biHeight
= 100;
1987 bmi
.bmiHeader
.biWidth
= 512;
1988 bmi
.bmiHeader
.biBitCount
= 24;
1989 bmi
.bmiHeader
.biPlanes
= 1;
1991 bmi
.bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
) - 1;
1993 hdib
= CreateDIBSection(hdc
, &bmi
, 0, NULL
, NULL
, 0);
1994 ok(hdib
== NULL
, "CreateDIBSection succeeded\n");
1996 bmi
.bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
1998 SetLastError(0xdeadbeef);
1999 hdib
= CreateDIBSection(hdc
, &bmi
, 0, NULL
, NULL
, 0);
2000 ok(hdib
!= NULL
, "CreateDIBSection error %d\n", GetLastError());
2003 bmi
.bmiHeader
.biSize
++;
2005 SetLastError(0xdeadbeef);
2006 hdib
= CreateDIBSection(hdc
, &bmi
, 0, NULL
, NULL
, 0);
2007 ok(hdib
!= NULL
, "CreateDIBSection error %d\n", GetLastError());
2010 bmi
.bmiHeader
.biSize
= sizeof(BITMAPINFO
);
2012 SetLastError(0xdeadbeef);
2013 hdib
= CreateDIBSection(hdc
, &bmi
, 0, NULL
, NULL
, 0);
2014 ok(hdib
!= NULL
, "CreateDIBSection error %d\n", GetLastError());
2017 bmi
.bmiHeader
.biSize
++;
2019 SetLastError(0xdeadbeef);
2020 hdib
= CreateDIBSection(hdc
, &bmi
, 0, NULL
, NULL
, 0);
2021 ok(hdib
!= NULL
, "CreateDIBSection error %d\n", GetLastError());
2024 bmi
.bmiHeader
.biSize
= sizeof(BITMAPV4HEADER
);
2026 SetLastError(0xdeadbeef);
2027 hdib
= CreateDIBSection(hdc
, &bmi
, 0, NULL
, NULL
, 0);
2028 ok(hdib
!= NULL
, "CreateDIBSection error %d\n", GetLastError());
2031 bmi
.bmiHeader
.biSize
= sizeof(BITMAPV5HEADER
);
2033 SetLastError(0xdeadbeef);
2034 hdib
= CreateDIBSection(hdc
, &bmi
, 0, NULL
, NULL
, 0);
2035 ok(hdib
!= NULL
, "CreateDIBSection error %d\n", GetLastError());
2038 memset(&bci
, 0, sizeof(BITMAPCOREINFO
));
2039 bci
.bmciHeader
.bcHeight
= 100;
2040 bci
.bmciHeader
.bcWidth
= 512;
2041 bci
.bmciHeader
.bcBitCount
= 24;
2042 bci
.bmciHeader
.bcPlanes
= 1;
2044 bci
.bmciHeader
.bcSize
= sizeof(BITMAPCOREHEADER
) - 1;
2046 hdib
= CreateDIBSection(hdc
, (BITMAPINFO
*)&bci
, 0, NULL
, NULL
, 0);
2047 ok(hdib
== NULL
, "CreateDIBSection succeeded\n");
2049 bci
.bmciHeader
.bcSize
= sizeof(BITMAPCOREHEADER
);
2051 SetLastError(0xdeadbeef);
2052 hdib
= CreateDIBSection(hdc
, (BITMAPINFO
*)&bci
, 0, NULL
, NULL
, 0);
2053 ok(hdib
!= NULL
, "CreateDIBSection error %d\n", GetLastError());
2056 bci
.bmciHeader
.bcSize
++;
2058 hdib
= CreateDIBSection(hdc
, (BITMAPINFO
*)&bci
, 0, NULL
, NULL
, 0);
2059 ok(hdib
== NULL
, "CreateDIBSection succeeded\n");
2061 bci
.bmciHeader
.bcSize
= sizeof(BITMAPCOREINFO
);
2063 hdib
= CreateDIBSection(hdc
, (BITMAPINFO
*)&bci
, 0, NULL
, NULL
, 0);
2064 ok(hdib
== NULL
, "CreateDIBSection succeeded\n");
2069 static void test_get16dibits(void)
2071 BYTE bits
[4 * (16 / sizeof(BYTE
))];
2073 HDC screen_dc
= GetDC(NULL
);
2076 int info_len
= sizeof(BITMAPINFOHEADER
) + 1024;
2078 int overwritten_bytes
= 0;
2080 memset(bits
, 0, sizeof(bits
));
2081 hbmp
= CreateBitmap(2, 2, 1, 16, bits
);
2082 ok(hbmp
!= NULL
, "CreateBitmap failed\n");
2084 info
= HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY
, info_len
);
2087 memset(info
, '!', info_len
);
2088 memset(info
, 0, sizeof(info
->bmiHeader
));
2090 info
->bmiHeader
.biSize
= sizeof(info
->bmiHeader
);
2091 info
->bmiHeader
.biWidth
= 2;
2092 info
->bmiHeader
.biHeight
= 2;
2093 info
->bmiHeader
.biPlanes
= 1;
2094 info
->bmiHeader
.biCompression
= BI_RGB
;
2096 ret
= GetDIBits(screen_dc
, hbmp
, 0, 0, NULL
, info
, 0);
2097 ok(ret
!= 0, "GetDIBits failed\n");
2099 for (p
= ((BYTE
*) info
) + sizeof(info
->bmiHeader
); (p
- ((BYTE
*) info
)) < info_len
; p
++)
2101 overwritten_bytes
++;
2102 ok(overwritten_bytes
== 0, "GetDIBits wrote past the buffer given\n");
2104 HeapFree(GetProcessHeap(), 0, info
);
2106 ReleaseDC(NULL
, screen_dc
);
2109 void test_GdiAlphaBlend()
2111 /* test out-of-bound parameters for GdiAlphaBlend */
2124 BLENDFUNCTION blend
;
2126 if (!pGdiAlphaBlend
)
2128 skip("GdiAlphaBlend() is not implemented\n");
2132 hdcNull
= GetDC(NULL
);
2133 hdcDst
= CreateCompatibleDC(hdcNull
);
2134 bmpDst
= CreateCompatibleBitmap(hdcNull
, 100, 100);
2135 hdcSrc
= CreateCompatibleDC(hdcNull
);
2137 memset(&bmi
, 0, sizeof(bmi
)); /* as of Wine 0.9.44 we require the src to be a DIB section */
2138 bmi
.bmiHeader
.biSize
= sizeof(bmi
.bmiHeader
);
2139 bmi
.bmiHeader
.biHeight
= 20;
2140 bmi
.bmiHeader
.biWidth
= 20;
2141 bmi
.bmiHeader
.biBitCount
= 32;
2142 bmi
.bmiHeader
.biPlanes
= 1;
2143 bmi
.bmiHeader
.biCompression
= BI_RGB
;
2144 bmpSrc
= CreateDIBSection(hdcDst
, &bmi
, DIB_RGB_COLORS
, &bits
, NULL
, 0);
2145 ok(bmpSrc
!= NULL
, "Couldn't create source bitmap\n");
2147 oldDst
= (HBITMAP
)SelectObject(hdcDst
, bmpDst
);
2148 oldSrc
= (HBITMAP
)SelectObject(hdcSrc
, bmpSrc
);
2150 blend
.BlendOp
= AC_SRC_OVER
;
2151 blend
.BlendFlags
= 0;
2152 blend
.SourceConstantAlpha
= 128;
2153 blend
.AlphaFormat
= 0;
2155 expect_eq(pGdiAlphaBlend(hdcDst
, 0, 0, 20, 20, hdcSrc
, 0, 0, 20, 20, blend
), TRUE
, BOOL
, "%d");
2156 SetLastError(0xdeadbeef);
2157 expect_eq(pGdiAlphaBlend(hdcDst
, 0, 0, 20, 20, hdcSrc
, -1, 0, 10, 10, blend
), FALSE
, BOOL
, "%d");
2158 expect_eq(GetLastError(), ERROR_INVALID_PARAMETER
, int, "%d");
2159 expect_eq(pGdiAlphaBlend(hdcDst
, 0, 0, 20, 20, hdcSrc
, 0, -1, 10, 10, blend
), FALSE
, BOOL
, "%d");
2160 expect_eq(pGdiAlphaBlend(hdcDst
, 0, 0, 20, 20, hdcSrc
, 15, 0, 10, 10, blend
), FALSE
, BOOL
, "%d");
2161 expect_eq(pGdiAlphaBlend(hdcDst
, 0, 0, 20, 20, hdcSrc
, 10, 10, -2, 3, blend
), FALSE
, BOOL
, "%d");
2162 expect_eq(pGdiAlphaBlend(hdcDst
, 0, 0, 20, 20, hdcSrc
, 10, 10, -2, 3, blend
), FALSE
, BOOL
, "%d");
2164 SetWindowOrgEx(hdcSrc
, -10, -10, NULL
);
2165 expect_eq(pGdiAlphaBlend(hdcDst
, 0, 0, 20, 20, hdcSrc
, -1, 0, 10, 10, blend
), TRUE
, BOOL
, "%d");
2166 expect_eq(pGdiAlphaBlend(hdcDst
, 0, 0, 20, 20, hdcSrc
, 0, -1, 10, 10, blend
), TRUE
, BOOL
, "%d");
2167 SetMapMode(hdcSrc
, MM_ANISOTROPIC
);
2168 ScaleWindowExtEx(hdcSrc
, 10, 1, 10, 1, NULL
);
2169 expect_eq(pGdiAlphaBlend(hdcDst
, 0, 0, 20, 20, hdcSrc
, -1, 0, 30, 30, blend
), TRUE
, BOOL
, "%d");
2170 expect_eq(pGdiAlphaBlend(hdcDst
, 0, 0, 20, 20, hdcSrc
, 0, -1, 30, 30, blend
), TRUE
, BOOL
, "%d");
2172 SelectObject(hdcDst
, oldDst
);
2173 SelectObject(hdcSrc
, oldSrc
);
2174 DeleteObject(bmpSrc
);
2175 DeleteObject(bmpDst
);
2179 ReleaseDC(NULL
, hdcNull
);
2186 is_win9x
= GetWindowLongPtrW(GetDesktopWindow(), GWLP_WNDPROC
) == 0;
2188 hdll
= GetModuleHandle("gdi32.dll");
2189 pGdiAlphaBlend
= (void*)GetProcAddress(hdll
, "GdiAlphaBlend");
2191 test_createdibitmap();
2193 test_mono_dibsection();
2196 test_GetDIBits_selected_DIB(1);
2197 test_GetDIBits_selected_DIB(4);
2198 test_GetDIBits_selected_DIB(8);
2199 test_GetDIBits_selected_DDB(TRUE
);
2200 test_GetDIBits_selected_DDB(FALSE
);
2202 test_GetDIBits_BI_BITFIELDS();
2203 test_select_object();
2204 test_CreateBitmap();
2205 test_GdiAlphaBlend();
2206 test_bitmapinfoheadersize();