?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mlang/tests: Fix a pointer casting warning on 64-bit.
[wine/testsucceed.git] / dlls / gdi32 / tests / bitmap.c
blob3f8a67442d4bae79e2b88826ae9cd464fce9415a
1 /*
2 * Unit test suite for bitmaps
3 *
4 * Copyright 2004 Huw Davies
5 * Copyright 2006 Dmitry Timoshkov
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <stdarg.h>
23 #include <assert.h>
24 #include <string.h>
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winerror.h"
29 #include "wingdi.h"
30 #include "winuser.h"
31 #include "mmsystem.h"
32
33 #include "wine/test.h"
34
35 static BOOL (WINAPI *pGdiAlphaBlend)(HDC,int,int,int,int,HDC,int,int,int,int,BLENDFUNCTION);
36
37 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
38
39 static BOOL is_win9x;
40
41 static INT BITMAP_GetWidthBytes( INT bmWidth, INT bpp )
42 {
43 switch(bpp)
44 {
45 case 1:
46 return 2 * ((bmWidth+15) >> 4);
47
48 case 24:
49 bmWidth *= 3; /* fall through */
50 case 8:
51 return bmWidth + (bmWidth & 1);
52
53 case 32:
54 return bmWidth * 4;
55
56 case 16:
57 case 15:
58 return bmWidth * 2;
59
60 case 4:
61 return 2 * ((bmWidth+3) >> 2);
62
63 default:
64 trace("Unknown depth %d, please report.\n", bpp );
65 assert(0);
66 }
67 return -1;
68 }
69
70 static void test_bitmap_info(HBITMAP hbm, INT expected_depth, const BITMAPINFOHEADER *bmih)
71 {
72 BITMAP bm;
73 BITMAP bma[2];
74 INT ret, width_bytes;
75 char buf[512], buf_cmp[512];
76 DWORD gle;
77
78 ret = GetObject(hbm, sizeof(bm), &bm);
79 ok(ret == sizeof(bm), "GetObject returned %d\n", ret);
80
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);
89
90 assert(sizeof(buf) >= bm.bmWidthBytes * bm.bmHeight);
91 assert(sizeof(buf) == sizeof(buf_cmp));
92
93 SetLastError(0xdeadbeef);
94 ret = GetBitmapBits(hbm, 0, NULL);
95 gle=GetLastError();
96 ok(ret == bm.bmWidthBytes * bm.bmHeight || (ret == 0 && gle == ERROR_INVALID_PARAMETER /* Win9x */), "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
97
98 memset(buf_cmp, 0xAA, sizeof(buf_cmp));
99 memset(buf_cmp, 0, bm.bmWidthBytes * bm.bmHeight);
100
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");
105
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);
109
110 ret = GetObject(hbm, sizeof(bm) / 2, &bm);
111 ok(ret == 0 || broken(ret == sizeof(bm) / 2 /* Win9x */), "%d != 0\n", ret);
112
113 ret = GetObject(hbm, 0, &bm);
114 ok(ret == 0, "%d != 0\n", ret);
115
116 ret = GetObject(hbm, 1, &bm);
117 ok(ret == 0 || broken(ret == 1 /* Win9x */), "%d != 0\n", ret);
118
119 /* Don't trust Win9x not to try to write to NULL */
120 if (ret == 0)
121 {
122 ret = GetObject(hbm, 0, NULL);
123 ok(ret == sizeof(bm), "wrong size %d\n", ret);
124 }
125 }
126
127 static void test_createdibitmap(void)
128 {
129 HDC hdc, hdcmem;
130 BITMAPINFOHEADER bmih;
131 BITMAPINFO bm;
132 HBITMAP hbm, hbm_colour, hbm_old;
133 INT screen_depth;
134 DWORD pixel;
135
136 hdc = GetDC(0);
137 screen_depth = GetDeviceCaps(hdc, BITSPIXEL);
138 memset(&bmih, 0, sizeof(bmih));
139 bmih.biSize = sizeof(bmih);
140 bmih.biWidth = 10;
141 bmih.biHeight = 10;
142 bmih.biPlanes = 1;
143 bmih.biBitCount = 32;
144 bmih.biCompression = BI_RGB;
145
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.
148 */
149
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);
154 DeleteObject(hbm);
155
156 /* Then 16 */
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);
161 DeleteObject(hbm);
162
163 /* Then 1 */
164 bmih.biBitCount = 1;
165 hbm = CreateDIBitmap(hdc, &bmih, 0, NULL, NULL, 0);
166 ok(hbm != NULL, "CreateDIBitmap failed\n");
167 test_bitmap_info(hbm, screen_depth, &bmih);
168 DeleteObject(hbm);
169
170 /* Now with a monochrome dc we expect a monochrome bitmap */
171 hdcmem = CreateCompatibleDC(hdc);
172
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);
178 DeleteObject(hbm);
179
180 /* Then 16 */
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);
185 DeleteObject(hbm);
186
187 /* Then 1 */
188 bmih.biBitCount = 1;
189 hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
190 ok(hbm != NULL, "CreateDIBitmap failed\n");
191 test_bitmap_info(hbm, 1, &bmih);
192 DeleteObject(hbm);
193
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);
199
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);
205 DeleteObject(hbm);
206
207 /* Then 16 */
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);
212 DeleteObject(hbm);
213
214 /* Then 1 */
215 bmih.biBitCount = 1;
216 hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
217 ok(hbm != NULL, "CreateDIBitmap failed\n");
218 test_bitmap_info(hbm, screen_depth, &bmih);
219 DeleteObject(hbm);
220
221 SelectObject(hdcmem, hbm_old);
222 DeleteObject(hbm_colour);
223 DeleteDC(hdcmem);
224
225 /* If hdc == 0 then we get a 1 bpp bitmap */
226 if (!is_win9x) {
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);
231 DeleteObject(hbm);
232 }
233
234 /* Test how formats are converted */
235 pixel = 0xffffffff;
236 bmih.biBitCount = 1;
237 bmih.biWidth = 1;
238 bmih.biHeight = 1;
239
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");
250
251 pixel = 0xdeadbeef;
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);
255 DeleteObject(hbm);
256
257 ReleaseDC(0, hdc);
258 }
259
260 static INT DIB_GetWidthBytes( int width, int bpp )
261 {
262 int words;
263
264 switch (bpp)
265 {
266 case 1: words = (width + 31) / 32; break;
267 case 4: words = (width + 7) / 8; break;
268 case 8: words = (width + 3) / 4; break;
269 case 15:
270 case 16: words = (width + 1) / 2; break;
271 case 24: words = (width * 3 + 3)/4; break;
272 case 32: words = width; break;
273
274 default:
275 words=0;
276 trace("Unknown depth %d, please report.\n", bpp );
277 assert(0);
278 break;
279 }
280 return 4 * words;
281 }
282
283 static void test_dib_info(HBITMAP hbm, const void *bits, const BITMAPINFOHEADER *bmih)
284 {
285 BITMAP bm;
286 BITMAP bma[2];
287 DIBSECTION ds;
288 DIBSECTION dsa[2];
289 INT ret, bm_width_bytes, dib_width_bytes;
290 BYTE *buf;
291
292 ret = GetObject(hbm, sizeof(bm), &bm);
293 ok(ret == sizeof(bm), "GetObject returned %d\n", ret);
294
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);
302 else
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);
307
308 buf = HeapAlloc(GetProcessHeap(), 0, bm.bmWidthBytes * bm.bmHeight + 4096);
309
310 /* GetBitmapBits returns not 32-bit aligned data */
311 SetLastError(0xdeadbeef);
312 ret = GetBitmapBits(hbm, 0, NULL);
313 ok(ret == bm_width_bytes * bm.bmHeight ||
314 broken(ret == 0 && GetLastError() == ERROR_INVALID_PARAMETER), /* Win9x */
315 "%d != %d\n", ret, bm_width_bytes * bm.bmHeight);
316
317 memset(buf, 0xAA, bm.bmWidthBytes * bm.bmHeight + 4096);
318 ret = GetBitmapBits(hbm, bm.bmWidthBytes * bm.bmHeight + 4096, buf);
319 ok(ret == bm_width_bytes * bm.bmHeight, "%d != %d\n", ret, bm_width_bytes * bm.bmHeight);
320
321 HeapFree(GetProcessHeap(), 0, buf);
322
323 /* test various buffer sizes for GetObject */
324 memset(&ds, 0xAA, sizeof(ds));
325 ret = GetObject(hbm, sizeof(*bma) * 2, bma);
326 ok(ret == sizeof(*bma) || broken(ret == sizeof(*bma) * 2 /* Win9x */), "wrong size %d\n", ret);
327 ok(bm.bmWidth == bmih->biWidth, "wrong bm.bmWidth %d\n", bm.bmWidth);
328 ok(bm.bmHeight == bmih->biHeight, "wrong bm.bmHeight %d\n", bm.bmHeight);
329 ok(bm.bmBits == bits, "wrong bm.bmBits %p != %p\n", bm.bmBits, bits);
330
331 ret = GetObject(hbm, sizeof(bm) / 2, &bm);
332 ok(ret == 0 || broken(ret == sizeof(bm) / 2 /* Win9x */), "%d != 0\n", ret);
333
334 ret = GetObject(hbm, 0, &bm);
335 ok(ret == 0, "%d != 0\n", ret);
336
337 ret = GetObject(hbm, 1, &bm);
338 ok(ret == 0 || broken(ret == 1 /* Win9x */), "%d != 0\n", ret);
339
340 /* test various buffer sizes for GetObject */
341 ret = GetObject(hbm, 0, NULL);
342 ok(ret == sizeof(bm) || broken(ret == sizeof(DIBSECTION) /* Win9x */), "wrong size %d\n", ret);
343
344 ret = GetObject(hbm, sizeof(*dsa) * 2, dsa);
345 ok(ret == sizeof(*dsa) || broken(ret == sizeof(*dsa) * 2 /* Win9x */), "wrong size %d\n", ret);
346
347 memset(&ds, 0xAA, sizeof(ds));
348 ret = GetObject(hbm, sizeof(ds), &ds);
349 ok(ret == sizeof(ds), "wrong size %d\n", ret);
350
351 ok(ds.dsBm.bmBits == bits, "wrong bm.bmBits %p != %p\n", ds.dsBm.bmBits, bits);
352 if (ds.dsBm.bmWidthBytes != bm_width_bytes) /* Win2k bug */
353 ok(ds.dsBmih.biSizeImage == ds.dsBm.bmWidthBytes * ds.dsBm.bmHeight, "%u != %u\n",
354 ds.dsBmih.biSizeImage, ds.dsBm.bmWidthBytes * ds.dsBm.bmHeight);
355 ok(bmih->biSizeImage == 0, "%u != 0\n", bmih->biSizeImage);
356 ds.dsBmih.biSizeImage = 0;
357
358 ok(ds.dsBmih.biSize == bmih->biSize, "%u != %u\n", ds.dsBmih.biSize, bmih->biSize);
359 ok(ds.dsBmih.biWidth == bmih->biWidth, "%u != %u\n", ds.dsBmih.biWidth, bmih->biWidth);
360 ok(ds.dsBmih.biHeight == bmih->biHeight, "%u != %u\n", ds.dsBmih.biHeight, bmih->biHeight);
361 ok(ds.dsBmih.biPlanes == bmih->biPlanes, "%u != %u\n", ds.dsBmih.biPlanes, bmih->biPlanes);
362 ok(ds.dsBmih.biBitCount == bmih->biBitCount, "%u != %u\n", ds.dsBmih.biBitCount, bmih->biBitCount);
363 ok(ds.dsBmih.biCompression == bmih->biCompression, "%u != %u\n", ds.dsBmih.biCompression, bmih->biCompression);
364 ok(ds.dsBmih.biSizeImage == bmih->biSizeImage, "%u != %u\n", ds.dsBmih.biSizeImage, bmih->biSizeImage);
365 ok(ds.dsBmih.biXPelsPerMeter == bmih->biXPelsPerMeter, "%u != %u\n", ds.dsBmih.biXPelsPerMeter, bmih->biXPelsPerMeter);
366 ok(ds.dsBmih.biYPelsPerMeter == bmih->biYPelsPerMeter, "%u != %u\n", ds.dsBmih.biYPelsPerMeter, bmih->biYPelsPerMeter);
367
368 memset(&ds, 0xAA, sizeof(ds));
369 ret = GetObject(hbm, sizeof(ds) - 4, &ds);
370 ok(ret == sizeof(ds.dsBm) || broken(ret == (sizeof(ds) - 4) /* Win9x */), "wrong size %d\n", ret);
371 ok(ds.dsBm.bmWidth == bmih->biWidth, "%u != %u\n", ds.dsBmih.biWidth, bmih->biWidth);
372 ok(ds.dsBm.bmHeight == bmih->biHeight, "%u != %u\n", ds.dsBmih.biHeight, bmih->biHeight);
373 ok(ds.dsBm.bmBits == bits, "%p != %p\n", ds.dsBm.bmBits, bits);
374
375 ret = GetObject(hbm, 0, &ds);
376 ok(ret == 0, "%d != 0\n", ret);
377
378 ret = GetObject(hbm, 1, &ds);
379 ok(ret == 0 || broken(ret == 1 /* Win9x */), "%d != 0\n", ret);
380 }
381
382 #define test_color_todo(got, exp, txt, todo) \
383 if (!todo && got != exp && screen_depth < 24) { \
384 todo_wine ok(0, #txt " failed at %d-bit screen depth: got 0x%06x expected 0x%06x - skipping DIB tests\n", \
385 screen_depth, (UINT)got, (UINT)exp); \
386 return; \
387 } else if (todo) todo_wine { ok(got == exp, #txt " failed: got 0x%06x expected 0x%06x\n", (UINT)got, (UINT)exp); } \
388 else ok(got == exp, #txt " failed: got 0x%06x expected 0x%06x\n", (UINT)got, (UINT)exp) \
389
390 #define test_color(hdc, color, exp, todo_setp, todo_getp) \
391 { \
392 COLORREF c; \
393 c = SetPixel(hdc, 0, 0, color); \
394 if (!is_win9x) { test_color_todo(c, exp, SetPixel, todo_setp); } \
395 c = GetPixel(hdc, 0, 0); \
396 test_color_todo(c, exp, GetPixel, todo_getp); \
397 }
398
399 static void test_dibsections(void)
400 {
401 HDC hdc, hdcmem, hdcmem2;
402 HBITMAP hdib, oldbm, hdib2, oldbm2;
403 char bmibuf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)];
404 char bcibuf[sizeof(BITMAPCOREINFO) + 256 * sizeof(RGBTRIPLE)];
405 BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
406 BITMAPCOREINFO *pbci = (BITMAPCOREINFO *)bcibuf;
407 HBITMAP hcoredib;
408 char coreBits[256];
409 BYTE *bits;
410 RGBQUAD rgb[256];
411 int ret;
412 char logpalbuf[sizeof(LOGPALETTE) + 256 * sizeof(PALETTEENTRY)];
413 LOGPALETTE *plogpal = (LOGPALETTE*)logpalbuf;
414 WORD *index;
415 DWORD *bits32;
416 HPALETTE hpal, oldpal;
417 DIBSECTION dibsec;
418 COLORREF c0, c1;
419 int i;
420 int screen_depth;
421 MEMORY_BASIC_INFORMATION info;
422
423 hdc = GetDC(0);
424 screen_depth = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
425
426 memset(pbmi, 0, sizeof(bmibuf));
427 pbmi->bmiHeader.biSize = sizeof(pbmi->bmiHeader);
428 pbmi->bmiHeader.biHeight = 100;
429 pbmi->bmiHeader.biWidth = 512;
430 pbmi->bmiHeader.biBitCount = 24;
431 pbmi->bmiHeader.biPlanes = 1;
432 pbmi->bmiHeader.biCompression = BI_RGB;
433
434 SetLastError(0xdeadbeef);
435
436 /* invalid pointer for BITMAPINFO
437 (*bits should be NULL on error) */
438 bits = (BYTE*)0xdeadbeef;
439 hdib = CreateDIBSection(hdc, NULL, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
440 ok(hdib == NULL && bits == NULL, "CreateDIBSection failed for invalid parameter: bmi == 0x0\n");
441
442 hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
443 ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
444 ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIBSection\n");
445 ok(dibsec.dsBm.bmBits == bits, "dibsec.dsBits %p != bits %p\n", dibsec.dsBm.bmBits, bits);
446
447 /* test the DIB memory */
448 ok(VirtualQuery(bits, &info, sizeof(info)) == sizeof(info),
449 "VirtualQuery failed\n");
450 ok(info.BaseAddress == bits, "%p != %p\n", info.BaseAddress, bits);
451 ok(info.AllocationBase == bits, "%p != %p\n", info.AllocationBase, bits);
452 ok(info.AllocationProtect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.AllocationProtect);
453 ok(info.RegionSize == 0x26000, "0x%lx != 0x26000\n", info.RegionSize);
454 ok(info.State == MEM_COMMIT, "%x != MEM_COMMIT\n", info.State);
455 ok(info.Protect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.Protect);
456 ok(info.Type == MEM_PRIVATE, "%x != MEM_PRIVATE\n", info.Type);
457
458 test_dib_info(hdib, bits, &pbmi->bmiHeader);
459 DeleteObject(hdib);
460
461 pbmi->bmiHeader.biBitCount = 8;
462 pbmi->bmiHeader.biCompression = BI_RLE8;
463 SetLastError(0xdeadbeef);
464 hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
465 ok(hdib == NULL, "CreateDIBSection should fail when asked to create a compressed DIB section\n");
466 ok(GetLastError() == 0xdeadbeef, "wrong error %d\n", GetLastError());
467
468 pbmi->bmiHeader.biBitCount = 16;
469 pbmi->bmiHeader.biCompression = BI_BITFIELDS;
470 ((PDWORD)pbmi->bmiColors)[0] = 0xf800;
471 ((PDWORD)pbmi->bmiColors)[1] = 0x07e0;
472 ((PDWORD)pbmi->bmiColors)[2] = 0x001f;
473 SetLastError(0xdeadbeef);
474 hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
475 ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
476
477 /* test the DIB memory */
478 ok(VirtualQuery(bits, &info, sizeof(info)) == sizeof(info),
479 "VirtualQuery failed\n");
480 ok(info.BaseAddress == bits, "%p != %p\n", info.BaseAddress, bits);
481 ok(info.AllocationBase == bits, "%p != %p\n", info.AllocationBase, bits);
482 ok(info.AllocationProtect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.AllocationProtect);
483 ok(info.RegionSize == 0x19000, "0x%lx != 0x19000\n", info.RegionSize);
484 ok(info.State == MEM_COMMIT, "%x != MEM_COMMIT\n", info.State);
485 ok(info.Protect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.Protect);
486 ok(info.Type == MEM_PRIVATE, "%x != MEM_PRIVATE\n", info.Type);
487
488 test_dib_info(hdib, bits, &pbmi->bmiHeader);
489 DeleteObject(hdib);
490
491 memset(pbmi, 0, sizeof(bmibuf));
492 pbmi->bmiHeader.biSize = sizeof(pbmi->bmiHeader);
493 pbmi->bmiHeader.biHeight = 16;
494 pbmi->bmiHeader.biWidth = 16;
495 pbmi->bmiHeader.biBitCount = 1;
496 pbmi->bmiHeader.biPlanes = 1;
497 pbmi->bmiHeader.biCompression = BI_RGB;
498 pbmi->bmiColors[0].rgbRed = 0xff;
499 pbmi->bmiColors[0].rgbGreen = 0;
500 pbmi->bmiColors[0].rgbBlue = 0;
501 pbmi->bmiColors[1].rgbRed = 0;
502 pbmi->bmiColors[1].rgbGreen = 0;
503 pbmi->bmiColors[1].rgbBlue = 0xff;
504
505 hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
506 ok(hdib != NULL, "CreateDIBSection failed\n");
507 ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIBSection\n");
508 ok(dibsec.dsBmih.biClrUsed == 2,
509 "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 2);
510
511 /* Test if the old BITMAPCOREINFO structure is supported */
512
513 pbci->bmciHeader.bcSize = sizeof(BITMAPCOREHEADER);
514 pbci->bmciHeader.bcBitCount = 0;
515
516 if (!is_win9x) {
517 ret = GetDIBits(hdc, hdib, 0, 16, NULL, (BITMAPINFO*) pbci, DIB_RGB_COLORS);
518 ok(ret, "GetDIBits doesn't work with a BITMAPCOREHEADER\n");
519 ok((pbci->bmciHeader.bcWidth == 16) && (pbci->bmciHeader.bcHeight == 16)
520 && (pbci->bmciHeader.bcBitCount == 1) && (pbci->bmciHeader.bcPlanes == 1),
521 "GetDIBits did't fill in the BITMAPCOREHEADER structure properly\n");
522
523 ret = GetDIBits(hdc, hdib, 0, 16, &coreBits, (BITMAPINFO*) pbci, DIB_RGB_COLORS);
524 ok(ret, "GetDIBits doesn't work with a BITMAPCOREHEADER\n");
525 ok((pbci->bmciColors[0].rgbtRed == 0xff) && (pbci->bmciColors[0].rgbtGreen == 0) &&
526 (pbci->bmciColors[0].rgbtBlue == 0) && (pbci->bmciColors[1].rgbtRed == 0) &&
527 (pbci->bmciColors[1].rgbtGreen == 0) && (pbci->bmciColors[1].rgbtBlue == 0xff),
528 "The color table has not been translated to the old BITMAPCOREINFO format\n");
529
530 hcoredib = CreateDIBSection(hdc, (BITMAPINFO*) pbci, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
531 ok(hcoredib != NULL, "CreateDIBSection failed with a BITMAPCOREINFO\n");
532
533 ZeroMemory(pbci->bmciColors, 256 * sizeof(RGBTRIPLE));
534 ret = GetDIBits(hdc, hcoredib, 0, 16, &coreBits, (BITMAPINFO*) pbci, DIB_RGB_COLORS);
535 ok(ret, "GetDIBits doesn't work with a BITMAPCOREHEADER\n");
536 ok((pbci->bmciColors[0].rgbtRed == 0xff) && (pbci->bmciColors[0].rgbtGreen == 0) &&
537 (pbci->bmciColors[0].rgbtBlue == 0) && (pbci->bmciColors[1].rgbtRed == 0) &&
538 (pbci->bmciColors[1].rgbtGreen == 0) && (pbci->bmciColors[1].rgbtBlue == 0xff),
539 "The color table has not been translated to the old BITMAPCOREINFO format\n");
540
541 DeleteObject(hcoredib);
542 }
543
544 hdcmem = CreateCompatibleDC(hdc);
545 oldbm = SelectObject(hdcmem, hdib);
546
547 ret = GetDIBColorTable(hdcmem, 0, 2, rgb);
548 ok(ret == 2, "GetDIBColorTable returned %d\n", ret);
549 ok(!memcmp(rgb, pbmi->bmiColors, 2 * sizeof(RGBQUAD)),
550 "GetDIBColorTable returns table 0: r%02x g%02x b%02x res%02x 1: r%02x g%02x b%02x res%02x\n",
551 rgb[0].rgbRed, rgb[0].rgbGreen, rgb[0].rgbBlue, rgb[0].rgbReserved,
552 rgb[1].rgbRed, rgb[1].rgbGreen, rgb[1].rgbBlue, rgb[1].rgbReserved);
553
554 c0 = RGB(pbmi->bmiColors[0].rgbRed, pbmi->bmiColors[0].rgbGreen, pbmi->bmiColors[0].rgbBlue);
555 c1 = RGB(pbmi->bmiColors[1].rgbRed, pbmi->bmiColors[1].rgbGreen, pbmi->bmiColors[1].rgbBlue);
556
557 test_color(hdcmem, DIBINDEX(0), c0, 0, 1);
558 test_color(hdcmem, DIBINDEX(1), c1, 0, 1);
559 test_color(hdcmem, DIBINDEX(2), c0, 1, 1);
560 test_color(hdcmem, PALETTEINDEX(0), c0, 1, 1);
561 test_color(hdcmem, PALETTEINDEX(1), c0, 1, 1);
562 test_color(hdcmem, PALETTEINDEX(2), c0, 1, 1);
563 test_color(hdcmem, PALETTERGB(pbmi->bmiColors[0].rgbRed, pbmi->bmiColors[0].rgbGreen,
564 pbmi->bmiColors[0].rgbBlue), c0, 1, 1);
565 test_color(hdcmem, PALETTERGB(pbmi->bmiColors[1].rgbRed, pbmi->bmiColors[1].rgbGreen,
566 pbmi->bmiColors[1].rgbBlue), c1, 1, 1);
567 test_color(hdcmem, PALETTERGB(0, 0, 0), c0, 1, 1);
568 test_color(hdcmem, PALETTERGB(0xff, 0xff, 0xff), c0, 1, 1);
569 test_color(hdcmem, PALETTERGB(0, 0, 0xfe), c1, 1, 1);
570
571 SelectObject(hdcmem, oldbm);
572 DeleteObject(hdib);
573
574 pbmi->bmiColors[0].rgbRed = 0xff;
575 pbmi->bmiColors[0].rgbGreen = 0xff;
576 pbmi->bmiColors[0].rgbBlue = 0xff;
577 pbmi->bmiColors[1].rgbRed = 0;
578 pbmi->bmiColors[1].rgbGreen = 0;
579 pbmi->bmiColors[1].rgbBlue = 0;
580
581 hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
582 ok(hdib != NULL, "CreateDIBSection failed\n");
583
584 test_dib_info(hdib, bits, &pbmi->bmiHeader);
585
586 oldbm = SelectObject(hdcmem, hdib);
587
588 ret = GetDIBColorTable(hdcmem, 0, 2, rgb);
589 ok(ret == 2, "GetDIBColorTable returned %d\n", ret);
590 ok(!memcmp(rgb, pbmi->bmiColors, 2 * sizeof(RGBQUAD)),
591 "GetDIBColorTable returns table 0: r%02x g%02x b%02x res%02x 1: r%02x g%02x b%02x res%02x\n",
592 rgb[0].rgbRed, rgb[0].rgbGreen, rgb[0].rgbBlue, rgb[0].rgbReserved,
593 rgb[1].rgbRed, rgb[1].rgbGreen, rgb[1].rgbBlue, rgb[1].rgbReserved);
594
595 SelectObject(hdcmem, oldbm);
596 test_dib_info(hdib, bits, &pbmi->bmiHeader);
597 DeleteObject(hdib);
598
599 pbmi->bmiHeader.biBitCount = 4;
600 for (i = 0; i < 16; i++) {
601 pbmi->bmiColors[i].rgbRed = i;
602 pbmi->bmiColors[i].rgbGreen = 16-i;
603 pbmi->bmiColors[i].rgbBlue = 0;
604 }
605 hdib = CreateDIBSection(hdcmem, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
606 ok(hdib != NULL, "CreateDIBSection failed\n");
607 ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
608 ok(dibsec.dsBmih.biClrUsed == 16,
609 "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 16);
610 test_dib_info(hdib, bits, &pbmi->bmiHeader);
611 DeleteObject(hdib);
612
613 pbmi->bmiHeader.biBitCount = 8;
614
615 for (i = 0; i < 128; i++) {
616 pbmi->bmiColors[i].rgbRed = 255 - i * 2;
617 pbmi->bmiColors[i].rgbGreen = i * 2;
618 pbmi->bmiColors[i].rgbBlue = 0;
619 pbmi->bmiColors[255 - i].rgbRed = 0;
620 pbmi->bmiColors[255 - i].rgbGreen = i * 2;
621 pbmi->bmiColors[255 - i].rgbBlue = 255 - i * 2;
622 }
623 hdib = CreateDIBSection(hdcmem, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
624 ok(hdib != NULL, "CreateDIBSection failed\n");
625 ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
626 ok(dibsec.dsBmih.biClrUsed == 256,
627 "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 256);
628
629 oldbm = SelectObject(hdcmem, hdib);
630
631 for (i = 0; i < 256; i++) {
632 test_color(hdcmem, DIBINDEX(i),
633 RGB(pbmi->bmiColors[i].rgbRed, pbmi->bmiColors[i].rgbGreen, pbmi->bmiColors[i].rgbBlue), 0, 0);
634 test_color(hdcmem, PALETTERGB(pbmi->bmiColors[i].rgbRed, pbmi->bmiColors[i].rgbGreen, pbmi->bmiColors[i].rgbBlue),
635 RGB(pbmi->bmiColors[i].rgbRed, pbmi->bmiColors[i].rgbGreen, pbmi->bmiColors[i].rgbBlue), 0, 0);
636 }
637
638 SelectObject(hdcmem, oldbm);
639 test_dib_info(hdib, bits, &pbmi->bmiHeader);
640 DeleteObject(hdib);
641
642 pbmi->bmiHeader.biBitCount = 1;
643
644 /* Now create a palette and a palette indexed dib section */
645 memset(plogpal, 0, sizeof(logpalbuf));
646 plogpal->palVersion = 0x300;
647 plogpal->palNumEntries = 2;
648 plogpal->palPalEntry[0].peRed = 0xff;
649 plogpal->palPalEntry[0].peBlue = 0xff;
650 plogpal->palPalEntry[1].peGreen = 0xff;
651
652 index = (WORD*)pbmi->bmiColors;
653 *index++ = 0;
654 *index = 1;
655 hpal = CreatePalette(plogpal);
656 ok(hpal != NULL, "CreatePalette failed\n");
657 oldpal = SelectPalette(hdc, hpal, TRUE);
658 hdib = CreateDIBSection(hdc, pbmi, DIB_PAL_COLORS, (void**)&bits, NULL, 0);
659 ok(hdib != NULL, "CreateDIBSection failed\n");
660 ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
661 ok(dibsec.dsBmih.biClrUsed == 2,
662 "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 2);
663
664 /* The colour table has already been grabbed from the dc, so we select back the
665 old palette */
666
667 SelectPalette(hdc, oldpal, TRUE);
668 oldbm = SelectObject(hdcmem, hdib);
669 oldpal = SelectPalette(hdcmem, hpal, TRUE);
670
671 ret = GetDIBColorTable(hdcmem, 0, 2, rgb);
672 ok(ret == 2, "GetDIBColorTable returned %d\n", ret);
673 ok(rgb[0].rgbRed == 0xff && rgb[0].rgbBlue == 0xff && rgb[0].rgbGreen == 0 &&
674 rgb[1].rgbRed == 0 && rgb[1].rgbBlue == 0 && rgb[1].rgbGreen == 0xff,
675 "GetDIBColorTable returns table 0: r%02x g%02x b%02x res%02x 1: r%02x g%02x b%02x res%02x\n",
676 rgb[0].rgbRed, rgb[0].rgbGreen, rgb[0].rgbBlue, rgb[0].rgbReserved,
677 rgb[1].rgbRed, rgb[1].rgbGreen, rgb[1].rgbBlue, rgb[1].rgbReserved);
678
679 c0 = RGB(plogpal->palPalEntry[0].peRed, plogpal->palPalEntry[0].peGreen, plogpal->palPalEntry[0].peBlue);
680 c1 = RGB(plogpal->palPalEntry[1].peRed, plogpal->palPalEntry[1].peGreen, plogpal->palPalEntry[1].peBlue);
681
682 test_color(hdcmem, DIBINDEX(0), c0, 0, 1);
683 test_color(hdcmem, DIBINDEX(1), c1, 0, 1);
684 test_color(hdcmem, DIBINDEX(2), c0, 1, 1);
685 test_color(hdcmem, PALETTEINDEX(0), c0, 0, 1);
686 test_color(hdcmem, PALETTEINDEX(1), c1, 0, 1);
687 test_color(hdcmem, PALETTEINDEX(2), c0, 1, 1);
688 test_color(hdcmem, PALETTERGB(plogpal->palPalEntry[0].peRed, plogpal->palPalEntry[0].peGreen,
689 plogpal->palPalEntry[0].peBlue), c0, 1, 1);
690 test_color(hdcmem, PALETTERGB(plogpal->palPalEntry[1].peRed, plogpal->palPalEntry[1].peGreen,
691 plogpal->palPalEntry[1].peBlue), c1, 1, 1);
692 test_color(hdcmem, PALETTERGB(0, 0, 0), c1, 1, 1);
693 test_color(hdcmem, PALETTERGB(0xff, 0xff, 0xff), c0, 1, 1);
694 test_color(hdcmem, PALETTERGB(0, 0, 0xfe), c0, 1, 1);
695 test_color(hdcmem, PALETTERGB(0, 1, 0), c1, 1, 1);
696 test_color(hdcmem, PALETTERGB(0x3f, 0, 0x3f), c1, 1, 1);
697 test_color(hdcmem, PALETTERGB(0x40, 0, 0x40), c0, 1, 1);
698
699 /* Bottom and 2nd row from top green, everything else magenta */
700 bits[0] = bits[1] = 0xff;
701 bits[13 * 4] = bits[13*4 + 1] = 0xff;
702
703 test_dib_info(hdib, bits, &pbmi->bmiHeader);
704
705 pbmi->bmiHeader.biBitCount = 32;
706
707 hdib2 = CreateDIBSection(NULL, pbmi, DIB_RGB_COLORS, (void **)&bits32, NULL, 0);
708 ok(hdib2 != NULL, "CreateDIBSection failed\n");
709 hdcmem2 = CreateCompatibleDC(hdc);
710 oldbm2 = SelectObject(hdcmem2, hdib2);
711
712 BitBlt(hdcmem2, 0, 0, 16,16, hdcmem, 0, 0, SRCCOPY);
713
714 ok(bits32[0] == 0xff00, "lower left pixel is %08x\n", bits32[0]);
715 ok(bits32[17] == 0xff00ff, "bottom but one, left pixel is %08x\n", bits32[17]);
716
717 SelectObject(hdcmem2, oldbm2);
718 test_dib_info(hdib2, bits32, &pbmi->bmiHeader);
719 DeleteObject(hdib2);
720
721 SelectObject(hdcmem, oldbm);
722 SelectObject(hdcmem, oldpal);
723 DeleteObject(hdib);
724 DeleteObject(hpal);
725
726
727 pbmi->bmiHeader.biBitCount = 8;
728
729 memset(plogpal, 0, sizeof(logpalbuf));
730 plogpal->palVersion = 0x300;
731 plogpal->palNumEntries = 256;
732
733 for (i = 0; i < 128; i++) {
734 plogpal->palPalEntry[i].peRed = 255 - i * 2;
735 plogpal->palPalEntry[i].peBlue = i * 2;
736 plogpal->palPalEntry[i].peGreen = 0;
737 plogpal->palPalEntry[255 - i].peRed = 0;
738 plogpal->palPalEntry[255 - i].peGreen = i * 2;
739 plogpal->palPalEntry[255 - i].peBlue = 255 - i * 2;
740 }
741
742 index = (WORD*)pbmi->bmiColors;
743 for (i = 0; i < 256; i++) {
744 *index++ = i;
745 }
746
747 hpal = CreatePalette(plogpal);
748 ok(hpal != NULL, "CreatePalette failed\n");
749 oldpal = SelectPalette(hdc, hpal, TRUE);
750 hdib = CreateDIBSection(hdc, pbmi, DIB_PAL_COLORS, (void**)&bits, NULL, 0);
751 ok(hdib != NULL, "CreateDIBSection failed\n");
752 ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
753 ok(dibsec.dsBmih.biClrUsed == 256,
754 "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 256);
755
756 test_dib_info(hdib, bits, &pbmi->bmiHeader);
757
758 SelectPalette(hdc, oldpal, TRUE);
759 oldbm = SelectObject(hdcmem, hdib);
760 oldpal = SelectPalette(hdcmem, hpal, TRUE);
761
762 ret = GetDIBColorTable(hdcmem, 0, 256, rgb);
763 ok(ret == 256, "GetDIBColorTable returned %d\n", ret);
764 for (i = 0; i < 256; i++) {
765 ok(rgb[i].rgbRed == plogpal->palPalEntry[i].peRed &&
766 rgb[i].rgbBlue == plogpal->palPalEntry[i].peBlue &&
767 rgb[i].rgbGreen == plogpal->palPalEntry[i].peGreen,
768 "GetDIBColorTable returns table %d: r%02x g%02x b%02x res%02x\n",
769 i, rgb[i].rgbRed, rgb[i].rgbGreen, rgb[i].rgbBlue, rgb[i].rgbReserved);
770 }
771
772 for (i = 0; i < 256; i++) {
773 test_color(hdcmem, DIBINDEX(i),
774 RGB(plogpal->palPalEntry[i].peRed, plogpal->palPalEntry[i].peGreen, plogpal->palPalEntry[i].peBlue), 0, 0);
775 test_color(hdcmem, PALETTEINDEX(i),
776 RGB(plogpal->palPalEntry[i].peRed, plogpal->palPalEntry[i].peGreen, plogpal->palPalEntry[i].peBlue), 0, 0);
777 test_color(hdcmem, PALETTERGB(plogpal->palPalEntry[i].peRed, plogpal->palPalEntry[i].peGreen, plogpal->palPalEntry[i].peBlue),
778 RGB(plogpal->palPalEntry[i].peRed, plogpal->palPalEntry[i].peGreen, plogpal->palPalEntry[i].peBlue), 0, 0);
779 }
780
781 SelectPalette(hdcmem, oldpal, TRUE);
782 SelectObject(hdcmem, oldbm);
783 DeleteObject(hdib);
784 DeleteObject(hpal);
785
786
787 DeleteDC(hdcmem);
788 ReleaseDC(0, hdc);
789 }
790
791 static void test_mono_dibsection(void)
792 {
793 HDC hdc, memdc;
794 HBITMAP old_bm, mono_ds;
795 char bmibuf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)];
796 BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
797 BYTE bits[10 * 4];
798 BYTE *ds_bits;
799 int num;
800
801 hdc = GetDC(0);
802
803 memdc = CreateCompatibleDC(hdc);
804
805 memset(pbmi, 0, sizeof(bmibuf));
806 pbmi->bmiHeader.biSize = sizeof(pbmi->bmiHeader);
807 pbmi->bmiHeader.biHeight = 10;
808 pbmi->bmiHeader.biWidth = 10;
809 pbmi->bmiHeader.biBitCount = 1;
810 pbmi->bmiHeader.biPlanes = 1;
811 pbmi->bmiHeader.biCompression = BI_RGB;
812 pbmi->bmiColors[0].rgbRed = 0xff;
813 pbmi->bmiColors[0].rgbGreen = 0xff;
814 pbmi->bmiColors[0].rgbBlue = 0xff;
815 pbmi->bmiColors[1].rgbRed = 0x0;
816 pbmi->bmiColors[1].rgbGreen = 0x0;
817 pbmi->bmiColors[1].rgbBlue = 0x0;
818
819 /*
820 * First dib section is 'inverted' ie color[0] is white, color[1] is black
821 */
822
823 mono_ds = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&ds_bits, NULL, 0);
824 ok(mono_ds != NULL, "CreateDIBSection rets NULL\n");
825 old_bm = SelectObject(memdc, mono_ds);
826
827 /* black border, white interior */
828 Rectangle(memdc, 0, 0, 10, 10);
829 ok(ds_bits[0] == 0xff, "out_bits %02x\n", ds_bits[0]);
830 ok(ds_bits[4] == 0x80, "out_bits %02x\n", ds_bits[4]);
831
832 /* SetDIBitsToDevice with an inverted bmi -> inverted dib section */
833
834 memset(bits, 0, sizeof(bits));
835 bits[0] = 0xaa;
836
837 SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
838 ok(ds_bits[0] == 0xaa, "out_bits %02x\n", ds_bits[0]);
839
840 /* SetDIBitsToDevice with a normal bmi -> inverted dib section */
841
842 pbmi->bmiColors[0].rgbRed = 0x0;
843 pbmi->bmiColors[0].rgbGreen = 0x0;
844 pbmi->bmiColors[0].rgbBlue = 0x0;
845 pbmi->bmiColors[1].rgbRed = 0xff;
846 pbmi->bmiColors[1].rgbGreen = 0xff;
847 pbmi->bmiColors[1].rgbBlue = 0xff;
848
849 SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
850 ok(ds_bits[0] == 0x55, "out_bits %02x\n", ds_bits[0]);
851
852 SelectObject(memdc, old_bm);
853 DeleteObject(mono_ds);
854
855 /*
856 * Next dib section is 'normal' ie color[0] is black, color[1] is white
857 */
858
859 pbmi->bmiColors[0].rgbRed = 0x0;
860 pbmi->bmiColors[0].rgbGreen = 0x0;
861 pbmi->bmiColors[0].rgbBlue = 0x0;
862 pbmi->bmiColors[1].rgbRed = 0xff;
863 pbmi->bmiColors[1].rgbGreen = 0xff;
864 pbmi->bmiColors[1].rgbBlue = 0xff;
865
866 mono_ds = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&ds_bits, NULL, 0);
867 ok(mono_ds != NULL, "CreateDIBSection rets NULL\n");
868 old_bm = SelectObject(memdc, mono_ds);
869
870 /* black border, white interior */
871 Rectangle(memdc, 0, 0, 10, 10);
872 ok(ds_bits[0] == 0x00, "out_bits %02x\n", ds_bits[0]);
873 ok(ds_bits[4] == 0x7f, "out_bits %02x\n", ds_bits[4]);
874
875 /* SetDIBitsToDevice with a normal bmi -> normal dib section */
876
877 SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
878 ok(ds_bits[0] == 0xaa, "out_bits %02x\n", ds_bits[0]);
879
880 /* SetDIBitsToDevice with a inverted bmi -> normal dib section */
881
882 pbmi->bmiColors[0].rgbRed = 0xff;
883 pbmi->bmiColors[0].rgbGreen = 0xff;
884 pbmi->bmiColors[0].rgbBlue = 0xff;
885 pbmi->bmiColors[1].rgbRed = 0x0;
886 pbmi->bmiColors[1].rgbGreen = 0x0;
887 pbmi->bmiColors[1].rgbBlue = 0x0;
888
889 SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
890 ok(ds_bits[0] == 0x55, "out_bits %02x\n", ds_bits[0]);
891
892 /*
893 * Take that 'normal' dibsection and change its colour table to an 'inverted' one
894 */
895
896 pbmi->bmiColors[0].rgbRed = 0xff;
897 pbmi->bmiColors[0].rgbGreen = 0xff;
898 pbmi->bmiColors[0].rgbBlue = 0xff;
899 pbmi->bmiColors[1].rgbRed = 0x0;
900 pbmi->bmiColors[1].rgbGreen = 0x0;
901 pbmi->bmiColors[1].rgbBlue = 0x0;
902 num = SetDIBColorTable(memdc, 0, 2, pbmi->bmiColors);
903 ok(num == 2, "num = %d\n", num);
904
905 /* black border, white interior */
906 Rectangle(memdc, 0, 0, 10, 10);
907 todo_wine {
908 ok(ds_bits[0] == 0xff, "out_bits %02x\n", ds_bits[0]);
909 ok(ds_bits[4] == 0x80, "out_bits %02x\n", ds_bits[4]);
910 }
911 /* SetDIBitsToDevice with an inverted bmi -> inverted dib section */
912
913 memset(bits, 0, sizeof(bits));
914 bits[0] = 0xaa;
915
916 SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
917 ok(ds_bits[0] == 0xaa, "out_bits %02x\n", ds_bits[0]);
918
919 /* SetDIBitsToDevice with a normal bmi -> inverted dib section */
920
921 pbmi->bmiColors[0].rgbRed = 0x0;
922 pbmi->bmiColors[0].rgbGreen = 0x0;
923 pbmi->bmiColors[0].rgbBlue = 0x0;
924 pbmi->bmiColors[1].rgbRed = 0xff;
925 pbmi->bmiColors[1].rgbGreen = 0xff;
926 pbmi->bmiColors[1].rgbBlue = 0xff;
927
928 SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
929 ok(ds_bits[0] == 0x55, "out_bits %02x\n", ds_bits[0]);
930
931 SelectObject(memdc, old_bm);
932 DeleteObject(mono_ds);
933
934 /*
935 * Now a dib section with a strange colour map just for fun. This behaves just like an inverted one.
936 */
937
938 pbmi->bmiColors[0].rgbRed = 0xff;
939 pbmi->bmiColors[0].rgbGreen = 0x0;
940 pbmi->bmiColors[0].rgbBlue = 0x0;
941 pbmi->bmiColors[1].rgbRed = 0xfe;
942 pbmi->bmiColors[1].rgbGreen = 0x0;
943 pbmi->bmiColors[1].rgbBlue = 0x0;
944
945 mono_ds = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&ds_bits, NULL, 0);
946 ok(mono_ds != NULL, "CreateDIBSection rets NULL\n");
947 old_bm = SelectObject(memdc, mono_ds);
948
949 /* black border, white interior */
950 Rectangle(memdc, 0, 0, 10, 10);
951 ok(ds_bits[0] == 0xff, "out_bits %02x\n", ds_bits[0]);
952 ok(ds_bits[4] == 0x80, "out_bits %02x\n", ds_bits[4]);
953
954 /* SetDIBitsToDevice with a normal bmi -> inverted dib section */
955
956 pbmi->bmiColors[0].rgbRed = 0x0;
957 pbmi->bmiColors[0].rgbGreen = 0x0;
958 pbmi->bmiColors[0].rgbBlue = 0x0;
959 pbmi->bmiColors[1].rgbRed = 0xff;
960 pbmi->bmiColors[1].rgbGreen = 0xff;
961 pbmi->bmiColors[1].rgbBlue = 0xff;
962
963 SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
964 ok(ds_bits[0] == 0x55, "out_bits %02x\n", ds_bits[0]);
965
966 /* SetDIBitsToDevice with a inverted bmi -> inverted dib section */
967
968 pbmi->bmiColors[0].rgbRed = 0xff;
969 pbmi->bmiColors[0].rgbGreen = 0xff;
970 pbmi->bmiColors[0].rgbBlue = 0xff;
971 pbmi->bmiColors[1].rgbRed = 0x0;
972 pbmi->bmiColors[1].rgbGreen = 0x0;
973 pbmi->bmiColors[1].rgbBlue = 0x0;
974
975 SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
976 ok(ds_bits[0] == 0xaa, "out_bits %02x\n", ds_bits[0]);
977
978 SelectObject(memdc, old_bm);
979 DeleteObject(mono_ds);
980
981 DeleteDC(memdc);
982 ReleaseDC(0, hdc);
983 }
984
985 static void test_bitmap(void)
986 {
987 char buf[256], buf_cmp[256];
988 HBITMAP hbmp, hbmp_old;
989 HDC hdc;
990 BITMAP bm;
991 BITMAP bma[2];
992 INT ret;
993
994 hdc = CreateCompatibleDC(0);
995 assert(hdc != 0);
996
997 SetLastError(0xdeadbeef);
998 hbmp = CreateBitmap(0x7ffffff, 1, 1, 1, NULL);
999 if (!hbmp)
1000 {
1001 ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY /* XP */ ||
1002 GetLastError() == ERROR_INVALID_PARAMETER /* Win2k */,
1003 "expected ERROR_NOT_ENOUGH_MEMORY, got %u\n", GetLastError());
1004 }
1005 else
1006 DeleteObject(hbmp);
1007
1008 SetLastError(0xdeadbeef);
1009 hbmp = CreateBitmap(0x7ffffff, 9, 1, 1, NULL);
1010 if (!hbmp)
1011 {
1012 ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY /* XP */ ||
1013 GetLastError() == ERROR_INVALID_PARAMETER /* Win2k */,
1014 "expected ERROR_NOT_ENOUGH_MEMORY, got %u\n", GetLastError());
1015 }
1016 else
1017 DeleteObject(hbmp);
1018
1019 SetLastError(0xdeadbeef);
1020 hbmp = CreateBitmap(0x7ffffff + 1, 1, 1, 1, NULL);
1021 ok(!hbmp || broken(hbmp != NULL /* Win9x */), "CreateBitmap should fail\n");
1022 if (!hbmp)
1023 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1024 "expected ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1025 else
1026 DeleteObject(hbmp);
1027
1028 hbmp = CreateBitmap(15, 15, 1, 1, NULL);
1029 assert(hbmp != NULL);
1030
1031 ret = GetObject(hbmp, sizeof(bm), &bm);
1032 ok(ret == sizeof(bm), "wrong size %d\n", ret);
1033
1034 ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
1035 ok(bm.bmWidth == 15, "wrong bm.bmWidth %d\n", bm.bmWidth);
1036 ok(bm.bmHeight == 15, "wrong bm.bmHeight %d\n", bm.bmHeight);
1037 ok(bm.bmWidthBytes == 2, "wrong bm.bmWidthBytes %d\n", bm.bmWidthBytes);
1038 ok(bm.bmPlanes == 1, "wrong bm.bmPlanes %d\n", bm.bmPlanes);
1039 ok(bm.bmBitsPixel == 1, "wrong bm.bmBitsPixel %d\n", bm.bmBitsPixel);
1040 ok(bm.bmBits == NULL, "wrong bm.bmBits %p\n", bm.bmBits);
1041
1042 assert(sizeof(buf) >= bm.bmWidthBytes * bm.bmHeight);
1043 assert(sizeof(buf) == sizeof(buf_cmp));
1044
1045 ret = GetBitmapBits(hbmp, 0, NULL);
1046 ok(ret == bm.bmWidthBytes * bm.bmHeight || broken(ret == 0 /* Win9x */),
1047 "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
1048
1049 memset(buf_cmp, 0xAA, sizeof(buf_cmp));
1050 memset(buf_cmp, 0, bm.bmWidthBytes * bm.bmHeight);
1051
1052 memset(buf, 0xAA, sizeof(buf));
1053 ret = GetBitmapBits(hbmp, sizeof(buf), buf);
1054 ok(ret == bm.bmWidthBytes * bm.bmHeight, "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
1055 ok(!memcmp(buf, buf_cmp, sizeof(buf)), "buffers do not match\n");
1056
1057 hbmp_old = SelectObject(hdc, hbmp);
1058
1059 ret = GetObject(hbmp, sizeof(bm), &bm);
1060 ok(ret == sizeof(bm), "wrong size %d\n", ret);
1061
1062 ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
1063 ok(bm.bmWidth == 15, "wrong bm.bmWidth %d\n", bm.bmWidth);
1064 ok(bm.bmHeight == 15, "wrong bm.bmHeight %d\n", bm.bmHeight);
1065 ok(bm.bmWidthBytes == 2, "wrong bm.bmWidthBytes %d\n", bm.bmWidthBytes);
1066 ok(bm.bmPlanes == 1, "wrong bm.bmPlanes %d\n", bm.bmPlanes);
1067 ok(bm.bmBitsPixel == 1, "wrong bm.bmBitsPixel %d\n", bm.bmBitsPixel);
1068 ok(bm.bmBits == NULL, "wrong bm.bmBits %p\n", bm.bmBits);
1069
1070 memset(buf, 0xAA, sizeof(buf));
1071 ret = GetBitmapBits(hbmp, sizeof(buf), buf);
1072 ok(ret == bm.bmWidthBytes * bm.bmHeight, "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
1073 ok(!memcmp(buf, buf_cmp, sizeof(buf)), "buffers do not match\n");
1074
1075 hbmp_old = SelectObject(hdc, hbmp_old);
1076 ok(hbmp_old == hbmp, "wrong old bitmap %p\n", hbmp_old);
1077
1078 /* test various buffer sizes for GetObject */
1079 ret = GetObject(hbmp, sizeof(*bma) * 2, bma);
1080 ok(ret == sizeof(*bma) || broken(ret == sizeof(*bma) * 2 /* Win9x */), "wrong size %d\n", ret);
1081
1082 ret = GetObject(hbmp, sizeof(bm) / 2, &bm);
1083 ok(ret == 0 || broken(ret == sizeof(bm) / 2 /* Win9x */), "%d != 0\n", ret);
1084
1085 ret = GetObject(hbmp, 0, &bm);
1086 ok(ret == 0, "%d != 0\n", ret);
1087
1088 ret = GetObject(hbmp, 1, &bm);
1089 ok(ret == 0 || broken(ret == 1 /* Win9x */), "%d != 0\n", ret);
1090
1091 DeleteObject(hbmp);
1092 DeleteDC(hdc);
1093 }
1094
1095 static void test_bmBits(void)
1096 {
1097 BYTE bits[4];
1098 HBITMAP hbmp;
1099 BITMAP bmp;
1100
1101 memset(bits, 0, sizeof(bits));
1102 hbmp = CreateBitmap(2, 2, 1, 4, bits);
1103 ok(hbmp != NULL, "CreateBitmap failed\n");
1104
1105 memset(&bmp, 0xFF, sizeof(bmp));
1106 ok(GetObject(hbmp, sizeof(bmp), &bmp) == sizeof(bmp),
1107 "GetObject failed or returned a wrong structure size\n");
1108 ok(!bmp.bmBits, "bmBits must be NULL for device-dependent bitmaps\n");
1109
1110 DeleteObject(hbmp);
1111 }
1112
1113 static void test_GetDIBits_selected_DIB(UINT bpp)
1114 {
1115 HBITMAP dib;
1116 BITMAPINFO * info;
1117 BITMAPINFO * info2;
1118 void * bits;
1119 void * bits2;
1120 UINT dib_size;
1121 HDC dib_dc, dc;
1122 HBITMAP old_bmp;
1123 BOOL equalContents;
1124 UINT i;
1125 int res;
1126
1127 /* Create a DIB section with a color table */
1128
1129 info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + (1 << bpp) * sizeof(RGBQUAD));
1130 info2 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + (1 << bpp) * sizeof(RGBQUAD));
1131 assert(info);
1132 assert(info2);
1133
1134 info->bmiHeader.biSize = sizeof(info->bmiHeader);
1135
1136 /* Choose width and height such that the row length (in bytes)
1137 is a multiple of 4 (makes things easier) */
1138 info->bmiHeader.biWidth = 32;
1139 info->bmiHeader.biHeight = 32;
1140 info->bmiHeader.biPlanes = 1;
1141 info->bmiHeader.biBitCount = bpp;
1142 info->bmiHeader.biCompression = BI_RGB;
1143
1144 for (i=0; i < (1u << bpp); i++)
1145 {
1146 BYTE c = i * (1 << (8 - bpp));
1147 info->bmiColors[i].rgbRed = c;
1148 info->bmiColors[i].rgbGreen = c;
1149 info->bmiColors[i].rgbBlue = c;
1150 info->bmiColors[i].rgbReserved = 0;
1151 }
1152
1153 dib = CreateDIBSection(NULL, info, DIB_RGB_COLORS, &bits, NULL, 0);
1154 assert(dib);
1155 dib_size = bpp * (info->bmiHeader.biWidth * info->bmiHeader.biHeight) / 8;
1156
1157 /* Set the bits of the DIB section */
1158 for (i=0; i < dib_size; i++)
1159 {
1160 ((BYTE *)bits)[i] = i % 256;
1161 }
1162
1163 /* Select the DIB into a DC */
1164 dib_dc = CreateCompatibleDC(NULL);
1165 old_bmp = SelectObject(dib_dc, dib);
1166 dc = CreateCompatibleDC(NULL);
1167 bits2 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dib_size);
1168 assert(bits2);
1169
1170 /* Copy the DIB attributes but not the color table */
1171 memcpy(info2, info, sizeof(BITMAPINFOHEADER));
1172
1173 res = GetDIBits(dc, dib, 0, info->bmiHeader.biHeight, bits2, info2, DIB_RGB_COLORS);
1174 ok(res, "GetDIBits failed\n");
1175
1176 /* Compare the color table and the bits */
1177 equalContents = TRUE;
1178 for (i=0; i < (1u << bpp); i++)
1179 {
1180 if ((info->bmiColors[i].rgbRed != info2->bmiColors[i].rgbRed)
1181 || (info->bmiColors[i].rgbGreen != info2->bmiColors[i].rgbGreen)
1182 || (info->bmiColors[i].rgbBlue != info2->bmiColors[i].rgbBlue)
1183 || (info->bmiColors[i].rgbReserved != info2->bmiColors[i].rgbReserved))
1184 {
1185 equalContents = FALSE;
1186 break;
1187 }
1188 }
1189 ok(equalContents, "GetDIBits with DIB selected in DC: Invalid DIB color table\n");
1190
1191 equalContents = TRUE;
1192 for (i=0; i < dib_size / sizeof(DWORD); i++)
1193 {
1194 if (((DWORD *)bits)[i] != ((DWORD *)bits2)[i])
1195 {
1196 equalContents = FALSE;
1197 break;
1198 }
1199 }
1200 ok(equalContents, "GetDIBits with %d bpp DIB selected in DC: Invalid DIB bits\n",bpp);
1201
1202 HeapFree(GetProcessHeap(), 0, bits2);
1203 DeleteDC(dc);
1204
1205 SelectObject(dib_dc, old_bmp);
1206 DeleteDC(dib_dc);
1207 DeleteObject(dib);
1208
1209 HeapFree(GetProcessHeap(), 0, info2);
1210 HeapFree(GetProcessHeap(), 0, info);
1211 }
1212
1213 static void test_GetDIBits_selected_DDB(BOOL monochrome)
1214 {
1215 HBITMAP ddb;
1216 BITMAPINFO * info;
1217 BITMAPINFO * info2;
1218 void * bits;
1219 void * bits2;
1220 HDC ddb_dc, dc;
1221 HBITMAP old_bmp;
1222 BOOL equalContents;
1223 UINT width, height;
1224 UINT bpp;
1225 UINT i, j;
1226 int res;
1227
1228 width = height = 16;
1229
1230 /* Create a DDB (device-dependent bitmap) */
1231 if (monochrome)
1232 {
1233 bpp = 1;
1234 ddb = CreateBitmap(width, height, 1, 1, NULL);
1235 }
1236 else
1237 {
1238 HDC screen_dc = GetDC(NULL);
1239 bpp = GetDeviceCaps(screen_dc, BITSPIXEL) * GetDeviceCaps(screen_dc, PLANES);
1240 ddb = CreateCompatibleBitmap(screen_dc, width, height);
1241 ReleaseDC(NULL, screen_dc);
1242 }
1243
1244 /* Set the pixels */
1245 ddb_dc = CreateCompatibleDC(NULL);
1246 old_bmp = SelectObject(ddb_dc, ddb);
1247 for (i = 0; i < width; i++)
1248 {
1249 for (j=0; j < height; j++)
1250 {
1251 BYTE c = (i * width + j) % 256;
1252 SetPixelV(ddb_dc, i, j, RGB(c, c, c));
1253 }
1254 }
1255 SelectObject(ddb_dc, old_bmp);
1256
1257 info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1258 info2 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1259 assert(info);
1260 assert(info2);
1261
1262 info->bmiHeader.biSize = sizeof(info->bmiHeader);
1263 info->bmiHeader.biWidth = width;
1264 info->bmiHeader.biHeight = height;
1265 info->bmiHeader.biPlanes = 1;
1266 info->bmiHeader.biBitCount = bpp;
1267 info->bmiHeader.biCompression = BI_RGB;
1268
1269 dc = CreateCompatibleDC(NULL);
1270
1271 /* Fill in biSizeImage */
1272 GetDIBits(dc, ddb, 0, height, NULL, info, DIB_RGB_COLORS);
1273 ok(info->bmiHeader.biSizeImage != 0, "GetDIBits failed to get the DIB attributes\n");
1274
1275 bits = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, info->bmiHeader.biSizeImage);
1276 bits2 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, info->bmiHeader.biSizeImage);
1277 assert(bits);
1278 assert(bits2);
1279
1280 /* Get the bits */
1281 res = GetDIBits(dc, ddb, 0, height, bits, info, DIB_RGB_COLORS);
1282 ok(res, "GetDIBits failed\n");
1283
1284 /* Copy the DIB attributes but not the color table */
1285 memcpy(info2, info, sizeof(BITMAPINFOHEADER));
1286
1287 /* Select the DDB into another DC */
1288 old_bmp = SelectObject(ddb_dc, ddb);
1289
1290 /* Get the bits */
1291 res = GetDIBits(dc, ddb, 0, height, bits2, info2, DIB_RGB_COLORS);
1292 ok(res, "GetDIBits failed\n");
1293
1294 /* Compare the color table and the bits */
1295 if (bpp <= 8)
1296 {
1297 equalContents = TRUE;
1298 for (i=0; i < (1u << bpp); i++)
1299 {
1300 if ((info->bmiColors[i].rgbRed != info2->bmiColors[i].rgbRed)
1301 || (info->bmiColors[i].rgbGreen != info2->bmiColors[i].rgbGreen)
1302 || (info->bmiColors[i].rgbBlue != info2->bmiColors[i].rgbBlue)
1303 || (info->bmiColors[i].rgbReserved != info2->bmiColors[i].rgbReserved))
1304 {
1305 equalContents = FALSE;
1306 break;
1307 }
1308 }
1309 ok(equalContents, "GetDIBits with DDB selected in DC: Got a different color table\n");
1310 }
1311
1312 equalContents = TRUE;
1313 for (i=0; i < info->bmiHeader.biSizeImage / sizeof(DWORD); i++)
1314 {
1315 if (((DWORD *)bits)[i] != ((DWORD *)bits2)[i])
1316 {
1317 equalContents = FALSE;
1318 }
1319 }
1320 ok(equalContents, "GetDIBits with DDB selected in DC: Got different DIB bits\n");
1321
1322 /* Test the palette */
1323 equalContents = TRUE;
1324 if (info2->bmiHeader.biBitCount <= 8)
1325 {
1326 WORD *colors = (WORD*)info2->bmiColors;
1327
1328 /* Get the palette indices */
1329 res = GetDIBits(dc, ddb, 0, 0, NULL, info2, DIB_PAL_COLORS);
1330 if (res == 0 && GetLastError() == ERROR_INVALID_PARAMETER) /* Win9x */
1331 res = GetDIBits(dc, ddb, 0, height, NULL, info2, DIB_PAL_COLORS);
1332 ok(res, "GetDIBits failed\n");
1333
1334 for (i=0;i < 1 << info->bmiHeader.biSizeImage; i++)
1335 {
1336 if (colors[i] != i)
1337 {
1338 equalContents = FALSE;
1339 break;
1340 }
1341 }
1342 }
1343
1344 ok(equalContents, "GetDIBits with DDB selected in DC: non 1:1 palette indices\n");
1345
1346 HeapFree(GetProcessHeap(), 0, bits2);
1347 HeapFree(GetProcessHeap(), 0, bits);
1348 DeleteDC(dc);
1349
1350 SelectObject(ddb_dc, old_bmp);
1351 DeleteDC(ddb_dc);
1352 DeleteObject(ddb);
1353
1354 HeapFree(GetProcessHeap(), 0, info2);
1355 HeapFree(GetProcessHeap(), 0, info);
1356 }
1357
1358 static void test_GetDIBits(void)
1359 {
1360 /* 2-bytes aligned 1-bit bitmap data: 16x16 */
1361 static const BYTE bmp_bits_1[16 * 2] =
1362 {
1363 0xff,0xff, 0,0, 0xff,0xff, 0,0,
1364 0xff,0xff, 0,0, 0xff,0xff, 0,0,
1365 0xff,0xff, 0,0, 0xff,0xff, 0,0,
1366 0xff,0xff, 0,0, 0xff,0xff, 0,0
1367 };
1368 /* 4-bytes aligned 1-bit DIB data: 16x16 */
1369 static const BYTE dib_bits_1[16 * 4] =
1370 {
1371 0,0,0,0, 0xff,0xff,0,0, 0,0,0,0, 0xff,0xff,0,0,
1372 0,0,0,0, 0xff,0xff,0,0, 0,0,0,0, 0xff,0xff,0,0,
1373 0,0,0,0, 0xff,0xff,0,0, 0,0,0,0, 0xff,0xff,0,0,
1374 0,0,0,0, 0xff,0xff,0,0, 0,0,0,0, 0xff,0xff,0,0
1375 };
1376 /* 2-bytes aligned 24-bit bitmap data: 16x16 */
1377 static const BYTE bmp_bits_24[16 * 16*3] =
1378 {
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 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
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 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
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 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
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 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
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 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
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 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
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,
1402 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 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1404 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1405 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
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 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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 };
1412 /* 4-bytes aligned 24-bit DIB data: 16x16 */
1413 static const BYTE dib_bits_24[16 * 16*3] =
1414 {
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 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
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 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
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 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
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 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
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 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
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 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
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,
1438 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1439 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1440 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1441 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 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1443 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1444 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1445 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1446 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
1447 };
1448 HBITMAP hbmp;
1449 BITMAP bm;
1450 HDC hdc;
1451 int i, bytes, lines;
1452 BYTE buf[1024];
1453 char bi_buf[sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256];
1454 BITMAPINFO *bi = (BITMAPINFO *)bi_buf;
1455
1456 hdc = GetDC(0);
1457
1458 /* 1-bit source bitmap data */
1459 hbmp = CreateBitmap(16, 16, 1, 1, bmp_bits_1);
1460 ok(hbmp != 0, "CreateBitmap failed\n");
1461
1462 memset(&bm, 0xAA, sizeof(bm));
1463 bytes = GetObject(hbmp, sizeof(bm), &bm);
1464 ok(bytes == sizeof(bm), "GetObject returned %d\n", bytes);
1465 ok(bm.bmType == 0, "wrong bmType %d\n", bm.bmType);
1466 ok(bm.bmWidth == 16, "wrong bmWidth %d\n", bm.bmWidth);
1467 ok(bm.bmHeight == 16, "wrong bmHeight %d\n", bm.bmHeight);
1468 ok(bm.bmWidthBytes == 2, "wrong bmWidthBytes %d\n", bm.bmWidthBytes);
1469 ok(bm.bmPlanes == 1, "wrong bmPlanes %u\n", bm.bmPlanes);
1470 ok(bm.bmBitsPixel == 1, "wrong bmBitsPixel %d\n", bm.bmBitsPixel);
1471 ok(!bm.bmBits, "wrong bmBits %p\n", bm.bmBits);
1472
1473 bytes = GetBitmapBits(hbmp, 0, NULL);
1474 ok(bytes == sizeof(bmp_bits_1) || broken(bytes == 0 /* Win9x */), "expected 16*2 got %d bytes\n", bytes);
1475 bytes = GetBitmapBits(hbmp, sizeof(buf), buf);
1476 ok(bytes == sizeof(bmp_bits_1), "expected 16*2 got %d bytes\n", bytes);
1477 ok(!memcmp(buf, bmp_bits_1, sizeof(bmp_bits_1)), "bitmap bits don't match\n");
1478
1479 /* retrieve 1-bit DIB data */
1480 memset(bi, 0, sizeof(*bi));
1481 bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1482 bi->bmiHeader.biWidth = bm.bmWidth;
1483 bi->bmiHeader.biHeight = bm.bmHeight;
1484 bi->bmiHeader.biPlanes = 1;
1485 bi->bmiHeader.biBitCount = 1;
1486 bi->bmiHeader.biCompression = BI_RGB;
1487 bi->bmiHeader.biSizeImage = 0;
1488 memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1489 SetLastError(0xdeadbeef);
1490 lines = GetDIBits(0, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1491 ok(lines == 0, "GetDIBits copied %d lines with hdc = 0\n", lines);
1492 ok(GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError());
1493 ok(bi->bmiHeader.biSizeImage == 0, "expected 0, got %u\n", bi->bmiHeader.biSizeImage);
1494
1495 memset(buf, 0xAA, sizeof(buf));
1496 SetLastError(0xdeadbeef);
1497 lines = GetDIBits(hdc, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1498 ok(lines == bm.bmHeight, "GetDIBits copied %d lines of %d, error %u\n",
1499 lines, bm.bmHeight, GetLastError());
1500 ok(bi->bmiHeader.biSizeImage == sizeof(dib_bits_1), "expected 16*4, got %u\n", bi->bmiHeader.biSizeImage);
1501
1502 /* the color table consists of black and white */
1503 ok(bi->bmiColors[0].rgbRed == 0 && bi->bmiColors[0].rgbGreen == 0 &&
1504 bi->bmiColors[0].rgbBlue == 0 && bi->bmiColors[0].rgbReserved == 0,
1505 "expected bmiColors[0] 0,0,0,0 - got %x %x %x %x\n",
1506 bi->bmiColors[0].rgbRed, bi->bmiColors[0].rgbGreen,
1507 bi->bmiColors[0].rgbBlue, bi->bmiColors[0].rgbReserved);
1508 ok(bi->bmiColors[1].rgbRed == 0xff && bi->bmiColors[1].rgbGreen == 0xff &&
1509 bi->bmiColors[1].rgbBlue == 0xff && bi->bmiColors[1].rgbReserved == 0,
1510 "expected bmiColors[0] 0xff,0xff,0xff,0 - got %x %x %x %x\n",
1511 bi->bmiColors[1].rgbRed, bi->bmiColors[1].rgbGreen,
1512 bi->bmiColors[1].rgbBlue, bi->bmiColors[1].rgbReserved);
1513 for (i = 2; i < 256; i++)
1514 {
1515 ok(bi->bmiColors[i].rgbRed == 0xAA && bi->bmiColors[i].rgbGreen == 0xAA &&
1516 bi->bmiColors[i].rgbBlue == 0xAA && bi->bmiColors[i].rgbReserved == 0xAA,
1517 "expected bmiColors[%d] 0xAA,0xAA,0xAA,0xAA - got %x %x %x %x\n", i,
1518 bi->bmiColors[i].rgbRed, bi->bmiColors[i].rgbGreen,
1519 bi->bmiColors[i].rgbBlue, bi->bmiColors[i].rgbReserved);
1520 }
1521
1522 /* returned bits are DWORD aligned and upside down */
1523 todo_wine
1524 ok(!memcmp(buf, dib_bits_1, sizeof(dib_bits_1)), "DIB bits don't match\n");
1525
1526 /* Test the palette indices */
1527 memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1528 SetLastError(0xdeadbeef);
1529 lines = GetDIBits(hdc, hbmp, 0, 0, NULL, bi, DIB_PAL_COLORS);
1530
1531 ok(((WORD*)bi->bmiColors)[0] == 0, "Color 0 is %d\n", ((WORD*)bi->bmiColors)[0]);
1532 ok(((WORD*)bi->bmiColors)[1] == 1, "Color 1 is %d\n", ((WORD*)bi->bmiColors)[1]);
1533 for (i = 2; i < 256; i++)
1534 ok(((WORD*)bi->bmiColors)[i] == 0xAAAA, "Color %d is %d\n", i, ((WORD*)bi->bmiColors)[1]);
1535
1536 /* retrieve 24-bit DIB data */
1537 memset(bi, 0, sizeof(*bi));
1538 bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1539 bi->bmiHeader.biWidth = bm.bmWidth;
1540 bi->bmiHeader.biHeight = bm.bmHeight;
1541 bi->bmiHeader.biPlanes = 1;
1542 bi->bmiHeader.biBitCount = 24;
1543 bi->bmiHeader.biCompression = BI_RGB;
1544 bi->bmiHeader.biSizeImage = 0;
1545 memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1546 memset(buf, 0xAA, sizeof(buf));
1547 SetLastError(0xdeadbeef);
1548 lines = GetDIBits(hdc, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1549 ok(lines == bm.bmHeight, "GetDIBits copied %d lines of %d, error %u\n",
1550 lines, bm.bmHeight, GetLastError());
1551 ok(bi->bmiHeader.biSizeImage == sizeof(dib_bits_24), "expected 16*16*3, got %u\n", bi->bmiHeader.biSizeImage);
1552
1553 /* the color table doesn't exist for 24-bit images */
1554 for (i = 0; i < 256; i++)
1555 {
1556 ok(bi->bmiColors[i].rgbRed == 0xAA && bi->bmiColors[i].rgbGreen == 0xAA &&
1557 bi->bmiColors[i].rgbBlue == 0xAA && bi->bmiColors[i].rgbReserved == 0xAA,
1558 "expected bmiColors[%d] 0xAA,0xAA,0xAA,0xAA - got %x %x %x %x\n", i,
1559 bi->bmiColors[i].rgbRed, bi->bmiColors[i].rgbGreen,
1560 bi->bmiColors[i].rgbBlue, bi->bmiColors[i].rgbReserved);
1561 }
1562
1563 /* returned bits are DWORD aligned and upside down */
1564 ok(!memcmp(buf, dib_bits_24, sizeof(dib_bits_24)), "DIB bits don't match\n");
1565 DeleteObject(hbmp);
1566
1567 /* 24-bit source bitmap data */
1568 hbmp = CreateCompatibleBitmap(hdc, 16, 16);
1569 ok(hbmp != 0, "CreateBitmap failed\n");
1570 SetLastError(0xdeadbeef);
1571 bi->bmiHeader.biHeight = -bm.bmHeight; /* indicate bottom-up data */
1572 lines = SetDIBits(hdc, hbmp, 0, bm.bmHeight, bmp_bits_24, bi, DIB_RGB_COLORS);
1573 ok(lines == bm.bmHeight, "SetDIBits copied %d lines of %d, error %u\n",
1574 lines, bm.bmHeight, GetLastError());
1575
1576 memset(&bm, 0xAA, sizeof(bm));
1577 bytes = GetObject(hbmp, sizeof(bm), &bm);
1578 ok(bytes == sizeof(bm), "GetObject returned %d\n", bytes);
1579 ok(bm.bmType == 0, "wrong bmType %d\n", bm.bmType);
1580 ok(bm.bmWidth == 16, "wrong bmWidth %d\n", bm.bmWidth);
1581 ok(bm.bmHeight == 16, "wrong bmHeight %d\n", bm.bmHeight);
1582 ok(bm.bmWidthBytes == BITMAP_GetWidthBytes(bm.bmWidth, bm.bmBitsPixel), "wrong bmWidthBytes %d\n", bm.bmWidthBytes);
1583 ok(bm.bmPlanes == GetDeviceCaps(hdc, PLANES), "wrong bmPlanes %u\n", bm.bmPlanes);
1584 ok(bm.bmBitsPixel == GetDeviceCaps(hdc, BITSPIXEL), "wrong bmBitsPixel %d\n", bm.bmBitsPixel);
1585 ok(!bm.bmBits, "wrong bmBits %p\n", bm.bmBits);
1586
1587 bytes = GetBitmapBits(hbmp, 0, NULL);
1588 ok(bytes == bm.bmWidthBytes * bm.bmHeight, "expected %d got %d bytes\n",
1589 bm.bmWidthBytes * bm.bmHeight, bytes);
1590 bytes = GetBitmapBits(hbmp, sizeof(buf), buf);
1591 ok(bytes == bm.bmWidthBytes * bm.bmHeight, "expected %d got %d bytes\n",
1592 bm.bmWidthBytes * bm.bmHeight, bytes);
1593
1594 /* retrieve 1-bit DIB data */
1595 memset(bi, 0, sizeof(*bi));
1596 bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1597 bi->bmiHeader.biWidth = bm.bmWidth;
1598 bi->bmiHeader.biHeight = bm.bmHeight;
1599 bi->bmiHeader.biPlanes = 1;
1600 bi->bmiHeader.biBitCount = 1;
1601 bi->bmiHeader.biCompression = BI_RGB;
1602 bi->bmiHeader.biSizeImage = 0;
1603 memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1604 memset(buf, 0xAA, sizeof(buf));
1605 SetLastError(0xdeadbeef);
1606 lines = GetDIBits(hdc, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1607 ok(lines == bm.bmHeight, "GetDIBits copied %d lines of %d, error %u\n",
1608 lines, bm.bmHeight, GetLastError());
1609 ok(bi->bmiHeader.biSizeImage == sizeof(dib_bits_1), "expected 16*4, got %u\n", bi->bmiHeader.biSizeImage);
1610
1611 /* the color table consists of black and white */
1612 ok(bi->bmiColors[0].rgbRed == 0 && bi->bmiColors[0].rgbGreen == 0 &&
1613 bi->bmiColors[0].rgbBlue == 0 && bi->bmiColors[0].rgbReserved == 0,
1614 "expected bmiColors[0] 0,0,0,0 - got %x %x %x %x\n",
1615 bi->bmiColors[0].rgbRed, bi->bmiColors[0].rgbGreen,
1616 bi->bmiColors[0].rgbBlue, bi->bmiColors[0].rgbReserved);
1617 ok(bi->bmiColors[1].rgbRed == 0xff && bi->bmiColors[1].rgbGreen == 0xff &&
1618 bi->bmiColors[1].rgbBlue == 0xff && bi->bmiColors[1].rgbReserved == 0,
1619 "expected bmiColors[0] 0xff,0xff,0xff,0 - got %x %x %x %x\n",
1620 bi->bmiColors[1].rgbRed, bi->bmiColors[1].rgbGreen,
1621 bi->bmiColors[1].rgbBlue, bi->bmiColors[1].rgbReserved);
1622 for (i = 2; i < 256; i++)
1623 {
1624 ok(bi->bmiColors[i].rgbRed == 0xAA && bi->bmiColors[i].rgbGreen == 0xAA &&
1625 bi->bmiColors[i].rgbBlue == 0xAA && bi->bmiColors[i].rgbReserved == 0xAA,
1626 "expected bmiColors[%d] 0xAA,0xAA,0xAA,0xAA - got %x %x %x %x\n", i,
1627 bi->bmiColors[i].rgbRed, bi->bmiColors[i].rgbGreen,
1628 bi->bmiColors[i].rgbBlue, bi->bmiColors[i].rgbReserved);
1629 }
1630
1631 /* returned bits are DWORD aligned and upside down */
1632 todo_wine
1633 ok(!memcmp(buf, dib_bits_1, sizeof(dib_bits_1)), "DIB bits don't match\n");
1634
1635 /* Test the palette indices */
1636 memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1637 SetLastError(0xdeadbeef);
1638 lines = GetDIBits(hdc, hbmp, 0, 0, NULL, bi, DIB_PAL_COLORS);
1639
1640 ok(((WORD*)bi->bmiColors)[0] == 0, "Color 0 is %d\n", ((WORD*)bi->bmiColors)[0]);
1641 ok(((WORD*)bi->bmiColors)[1] == 1, "Color 1 is %d\n", ((WORD*)bi->bmiColors)[1]);
1642 for (i = 2; i < 256; i++)
1643 ok(((WORD*)bi->bmiColors)[i] == 0xAAAA, "Color %d is %d\n", i, ((WORD*)bi->bmiColors)[i]);
1644
1645 /* retrieve 24-bit DIB data */
1646 memset(bi, 0, sizeof(*bi));
1647 bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1648 bi->bmiHeader.biWidth = bm.bmWidth;
1649 bi->bmiHeader.biHeight = bm.bmHeight;
1650 bi->bmiHeader.biPlanes = 1;
1651 bi->bmiHeader.biBitCount = 24;
1652 bi->bmiHeader.biCompression = BI_RGB;
1653 bi->bmiHeader.biSizeImage = 0;
1654 memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1655 memset(buf, 0xAA, sizeof(buf));
1656 SetLastError(0xdeadbeef);
1657 lines = GetDIBits(hdc, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1658 ok(lines == bm.bmHeight, "GetDIBits copied %d lines of %d, error %u\n",
1659 lines, bm.bmHeight, GetLastError());
1660 ok(bi->bmiHeader.biSizeImage == sizeof(dib_bits_24), "expected 16*16*3, got %u\n", bi->bmiHeader.biSizeImage);
1661
1662 /* the color table doesn't exist for 24-bit images */
1663 for (i = 0; i < 256; i++)
1664 {
1665 ok(bi->bmiColors[i].rgbRed == 0xAA && bi->bmiColors[i].rgbGreen == 0xAA &&
1666 bi->bmiColors[i].rgbBlue == 0xAA && bi->bmiColors[i].rgbReserved == 0xAA,
1667 "expected bmiColors[%d] 0xAA,0xAA,0xAA,0xAA - got %x %x %x %x\n", i,
1668 bi->bmiColors[i].rgbRed, bi->bmiColors[i].rgbGreen,
1669 bi->bmiColors[i].rgbBlue, bi->bmiColors[i].rgbReserved);
1670 }
1671
1672 /* returned bits are DWORD aligned and upside down */
1673 ok(!memcmp(buf, dib_bits_24, sizeof(dib_bits_24)), "DIB bits don't match\n");
1674 DeleteObject(hbmp);
1675
1676 ReleaseDC(0, hdc);
1677 }
1678
1679 static void test_GetDIBits_BI_BITFIELDS(void)
1680 {
1681 /* Try a screen resolution detection technique
1682 * from the September 1999 issue of Windows Developer's Journal
1683 * which seems to be in widespread use.
1684 * http://www.lesher.ws/highcolor.html
1685 * http://www.lesher.ws/vidfmt.c
1686 * It hinges on being able to retrieve the bitmaps
1687 * for the three primary colors in non-paletted 16 bit mode.
1688 */
1689 char dibinfo_buf[sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD)];
1690 DWORD bits[32];
1691 LPBITMAPINFO dibinfo = (LPBITMAPINFO) dibinfo_buf;
1692 HDC hdc;
1693 HBITMAP hbm;
1694 int ret;
1695
1696 memset(dibinfo, 0, sizeof(dibinfo_buf));
1697 dibinfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1698
1699 hdc = GetDC(NULL);
1700 ok(hdc != NULL, "GetDC failed?\n");
1701 hbm = CreateCompatibleBitmap(hdc, 1, 1);
1702 ok(hbm != NULL, "CreateCompatibleBitmap failed?\n");
1703
1704 /* Call GetDIBits to fill in bmiHeader. */
1705 ret = GetDIBits(hdc, hbm, 0, 1, NULL, dibinfo, DIB_RGB_COLORS);
1706 ok(ret == 1, "GetDIBits failed\n");
1707 if (dibinfo->bmiHeader.biBitCount > 8)
1708 {
1709 DWORD *bitmasks = (DWORD *)dibinfo->bmiColors;
1710
1711 ok( dibinfo->bmiHeader.biCompression == BI_BITFIELDS,
1712 "compression is %u\n", dibinfo->bmiHeader.biCompression );
1713
1714 ok( !bitmasks[0], "red mask is set\n" );
1715 ok( !bitmasks[1], "green mask is set\n" );
1716 ok( !bitmasks[2], "blue mask is set\n" );
1717
1718 /* test with NULL bits pointer and correct bpp */
1719 dibinfo->bmiHeader.biSizeImage = 0xdeadbeef;
1720 ret = GetDIBits(hdc, hbm, 0, 1, NULL, dibinfo, DIB_RGB_COLORS);
1721 ok(ret == 1, "GetDIBits failed\n");
1722
1723 ok( bitmasks[0] != 0, "red mask is not set\n" );
1724 ok( bitmasks[1] != 0, "green mask is not set\n" );
1725 ok( bitmasks[2] != 0, "blue mask is not set\n" );
1726 ok( dibinfo->bmiHeader.biSizeImage != 0xdeadbeef, "size image not set\n" );
1727
1728 /* test with valid bits pointer */
1729 memset(dibinfo, 0, sizeof(dibinfo_buf));
1730 dibinfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1731 ret = GetDIBits(hdc, hbm, 0, 1, NULL, dibinfo, DIB_RGB_COLORS);
1732 ok(ret == 1, "GetDIBits failed ret %u err %u\n",ret,GetLastError());
1733 dibinfo->bmiHeader.biSizeImage = 0xdeadbeef;
1734 ret = GetDIBits(hdc, hbm, 0, 1, bits, dibinfo, DIB_RGB_COLORS);
1735 ok(ret == 1, "GetDIBits failed ret %u err %u\n",ret,GetLastError());
1736
1737 ok( bitmasks[0] != 0, "red mask is not set\n" );
1738 ok( bitmasks[1] != 0, "green mask is not set\n" );
1739 ok( bitmasks[2] != 0, "blue mask is not set\n" );
1740 ok( dibinfo->bmiHeader.biSizeImage != 0xdeadbeef, "size image not set\n" );
1741
1742 /* now with bits and 0 lines */
1743 memset(dibinfo, 0, sizeof(dibinfo_buf));
1744 dibinfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1745 dibinfo->bmiHeader.biSizeImage = 0xdeadbeef;
1746 SetLastError(0xdeadbeef);
1747 ret = GetDIBits(hdc, hbm, 0, 0, bits, dibinfo, DIB_RGB_COLORS);
1748 if (ret == 0 && GetLastError() == ERROR_INVALID_PARAMETER)
1749 win_skip("Win9x/WinMe doesn't handle 0 for the number of scan lines\n");
1750 else
1751 {
1752 ok(ret == 1, "GetDIBits failed ret %u err %u\n",ret,GetLastError());
1753
1754 ok( !bitmasks[0], "red mask is set\n" );
1755 ok( !bitmasks[1], "green mask is set\n" );
1756 ok( !bitmasks[2], "blue mask is set\n" );
1757 ok( dibinfo->bmiHeader.biSizeImage != 0xdeadbeef, "size image not set\n" );
1758
1759 memset(bitmasks, 0, 3*sizeof(DWORD));
1760 dibinfo->bmiHeader.biSizeImage = 0xdeadbeef;
1761 ret = GetDIBits(hdc, hbm, 0, 0, bits, dibinfo, DIB_RGB_COLORS);
1762 ok(ret == 1, "GetDIBits failed ret %u err %u\n",ret,GetLastError());
1763
1764 ok( bitmasks[0] != 0, "red mask is not set\n" );
1765 ok( bitmasks[1] != 0, "green mask is not set\n" );
1766 ok( bitmasks[2] != 0, "blue mask is not set\n" );
1767 ok( dibinfo->bmiHeader.biSizeImage != 0xdeadbeef, "size image not set\n" );
1768 }
1769 }
1770 else skip("not in 16 bpp BI_BITFIELDS mode, skipping that test\n");
1771
1772 DeleteObject(hbm);
1773 ReleaseDC(NULL, hdc);
1774 }
1775
1776 static void test_select_object(void)
1777 {
1778 HDC hdc;
1779 HBITMAP hbm, hbm_old;
1780 INT planes, bpp, i;
1781 DWORD depths[] = {8, 15, 16, 24, 32};
1782 BITMAP bm;
1783 DWORD bytes;
1784
1785 hdc = GetDC(0);
1786 ok(hdc != 0, "GetDC(0) failed\n");
1787 hbm = CreateCompatibleBitmap(hdc, 10, 10);
1788 ok(hbm != 0, "CreateCompatibleBitmap failed\n");
1789
1790 hbm_old = SelectObject(hdc, hbm);
1791 ok(hbm_old == 0, "SelectObject should fail\n");
1792
1793 DeleteObject(hbm);
1794 ReleaseDC(0, hdc);
1795
1796 hdc = CreateCompatibleDC(0);
1797 ok(hdc != 0, "GetDC(0) failed\n");
1798 hbm = CreateCompatibleBitmap(hdc, 10, 10);
1799 ok(hbm != 0, "CreateCompatibleBitmap failed\n");
1800
1801 hbm_old = SelectObject(hdc, hbm);
1802 ok(hbm_old != 0, "SelectObject failed\n");
1803 hbm_old = SelectObject(hdc, hbm_old);
1804 ok(hbm_old == hbm, "SelectObject failed\n");
1805
1806 DeleteObject(hbm);
1807
1808 /* test an 1-bpp bitmap */
1809 planes = GetDeviceCaps(hdc, PLANES);
1810 bpp = 1;
1811
1812 hbm = CreateBitmap(10, 10, planes, bpp, NULL);
1813 ok(hbm != 0, "CreateBitmap failed\n");
1814
1815 hbm_old = SelectObject(hdc, hbm);
1816 ok(hbm_old != 0, "SelectObject failed\n");
1817 hbm_old = SelectObject(hdc, hbm_old);
1818 ok(hbm_old == hbm, "SelectObject failed\n");
1819
1820 DeleteObject(hbm);
1821
1822 for(i = 0; i < sizeof(depths)/sizeof(depths[0]); i++) {
1823 /* test a color bitmap to dc bpp matching */
1824 planes = GetDeviceCaps(hdc, PLANES);
1825 bpp = GetDeviceCaps(hdc, BITSPIXEL);
1826
1827 hbm = CreateBitmap(10, 10, planes, depths[i], NULL);
1828 ok(hbm != 0, "CreateBitmap failed\n");
1829
1830 hbm_old = SelectObject(hdc, hbm);
1831 if(depths[i] == bpp ||
1832 (bpp == 16 && depths[i] == 15) /* 16 and 15 bpp are compatible */
1833 ) {
1834 ok(hbm_old != 0, "SelectObject failed, BITSPIXEL: %d, created depth: %d\n", bpp, depths[i]);
1835 SelectObject(hdc, hbm_old);
1836 } else {
1837 ok(hbm_old == 0, "SelectObject should fail. BITSPIXELS: %d, created depth: %d\n", bpp, depths[i]);
1838 }
1839
1840 memset(&bm, 0xAA, sizeof(bm));
1841 bytes = GetObject(hbm, sizeof(bm), &bm);
1842 ok(bytes == sizeof(bm), "GetObject returned %d\n", bytes);
1843 ok(bm.bmType == 0, "wrong bmType %d\n", bm.bmType);
1844 ok(bm.bmWidth == 10, "wrong bmWidth %d\n", bm.bmWidth);
1845 ok(bm.bmHeight == 10, "wrong bmHeight %d\n", bm.bmHeight);
1846 ok(bm.bmWidthBytes == BITMAP_GetWidthBytes(bm.bmWidth, bm.bmBitsPixel), "wrong bmWidthBytes %d\n", bm.bmWidthBytes);
1847 ok(bm.bmPlanes == planes, "wrong bmPlanes %u\n", bm.bmPlanes);
1848 if(depths[i] == 15) {
1849 ok(bm.bmBitsPixel == 16, "wrong bmBitsPixel %d(15 bpp special)\n", bm.bmBitsPixel);
1850 } else {
1851 ok(bm.bmBitsPixel == depths[i], "wrong bmBitsPixel %d\n", bm.bmBitsPixel);
1852 }
1853 ok(!bm.bmBits, "wrong bmBits %p\n", bm.bmBits);
1854
1855 DeleteObject(hbm);
1856 }
1857
1858 DeleteDC(hdc);
1859 }
1860
1861 static void test_mono_1x1_bmp_dbg(HBITMAP hbmp, int line)
1862 {
1863 INT ret;
1864 BITMAP bm;
1865
1866 ret = GetObjectType(hbmp);
1867 ok_(__FILE__, line)(ret == OBJ_BITMAP, "the object %p is not bitmap\n", hbmp);
1868
1869 ret = GetObject(hbmp, 0, 0);
1870 ok_(__FILE__, line)(ret == sizeof(BITMAP) /* XP */ ||
1871 ret == sizeof(DIBSECTION) /* Win9x */, "object size %d\n", ret);
1872
1873 memset(&bm, 0xDA, sizeof(bm));
1874 SetLastError(0xdeadbeef);
1875 ret = GetObject(hbmp, sizeof(bm), &bm);
1876 if (!ret) /* XP, only for curObj2 */ return;
1877 ok_(__FILE__, line)(ret == sizeof(BITMAP) ||
1878 ret == sizeof(DIBSECTION) /* Win9x, only for curObj2 */,
1879 "GetObject returned %d, error %u\n", ret, GetLastError());
1880 ok_(__FILE__, line)(bm.bmType == 0, "wrong bmType, expected 0 got %d\n", bm.bmType);
1881 ok_(__FILE__, line)(bm.bmWidth == 1, "wrong bmWidth, expected 1 got %d\n", bm.bmWidth);
1882 ok_(__FILE__, line)(bm.bmHeight == 1, "wrong bmHeight, expected 1 got %d\n", bm.bmHeight);
1883 ok_(__FILE__, line)(bm.bmWidthBytes == 2, "wrong bmWidthBytes, expected 2 got %d\n", bm.bmWidthBytes);
1884 ok_(__FILE__, line)(bm.bmPlanes == 1, "wrong bmPlanes, expected 1 got %u\n", bm.bmPlanes);
1885 ok_(__FILE__, line)(bm.bmBitsPixel == 1, "wrong bmBitsPixel, expected 1 got %d\n", bm.bmBitsPixel);
1886 ok_(__FILE__, line)(!bm.bmBits, "wrong bmBits %p\n", bm.bmBits);
1887 }
1888
1889 #define test_mono_1x1_bmp(a) test_mono_1x1_bmp_dbg((a), __LINE__)
1890
1891 static void test_CreateBitmap(void)
1892 {
1893 BITMAP bmp;
1894 HDC screenDC = GetDC(0);
1895 HDC hdc = CreateCompatibleDC(screenDC);
1896 UINT i, expect = 0;
1897
1898 /* all of these are the stock monochrome bitmap */
1899 HBITMAP bm = CreateCompatibleBitmap(hdc, 0, 0);
1900 HBITMAP bm1 = CreateCompatibleBitmap(screenDC, 0, 0);
1901 HBITMAP bm4 = CreateBitmap(0, 1, 0, 0, 0);
1902 HBITMAP bm5 = CreateDiscardableBitmap(hdc, 0, 0);
1903 HBITMAP curObj1 = GetCurrentObject(hdc, OBJ_BITMAP);
1904 HBITMAP curObj2 = GetCurrentObject(screenDC, OBJ_BITMAP);
1905
1906 /* these 2 are not the stock monochrome bitmap */
1907 HBITMAP bm2 = CreateCompatibleBitmap(hdc, 1, 1);
1908 HBITMAP bm3 = CreateBitmap(1, 1, 1, 1, 0);
1909
1910 HBITMAP old1 = SelectObject(hdc, bm2);
1911 HBITMAP old2 = SelectObject(screenDC, bm3);
1912 SelectObject(hdc, old1);
1913 SelectObject(screenDC, old2);
1914
1915 ok(bm == bm1 && bm == bm4 && bm == bm5 && bm == curObj1 && bm == old1,
1916 "0: %p, 1: %p, 4: %p, 5: %p, curObj1 %p, old1 %p\n",
1917 bm, bm1, bm4, bm5, curObj1, old1);
1918 ok(bm != bm2 && bm != bm3, "0: %p, 2: %p, 3: %p\n", bm, bm2, bm3);
1919 ok(bm != curObj2 /* XP */ || bm == curObj2 /* Win9x */,
1920 "0: %p, curObj2 %p\n", bm, curObj2);
1921 ok(old2 == 0, "old2 %p\n", old2);
1922
1923 test_mono_1x1_bmp(bm);
1924 test_mono_1x1_bmp(bm1);
1925 test_mono_1x1_bmp(bm2);
1926 test_mono_1x1_bmp(bm3);
1927 test_mono_1x1_bmp(bm4);
1928 test_mono_1x1_bmp(bm5);
1929 test_mono_1x1_bmp(old1);
1930 test_mono_1x1_bmp(curObj1);
1931 test_mono_1x1_bmp(curObj2);
1932
1933 DeleteObject(bm);
1934 DeleteObject(bm1);
1935 DeleteObject(bm2);
1936 DeleteObject(bm3);
1937 DeleteObject(bm4);
1938 DeleteObject(bm5);
1939
1940 DeleteDC(hdc);
1941 ReleaseDC(0, screenDC);
1942
1943 /* show that Windows ignores the provided bm.bmWidthBytes */
1944 bmp.bmType = 0;
1945 bmp.bmWidth = 1;
1946 bmp.bmHeight = 1;
1947 bmp.bmWidthBytes = 28;
1948 bmp.bmPlanes = 1;
1949 bmp.bmBitsPixel = 1;
1950 bmp.bmBits = NULL;
1951 bm = CreateBitmapIndirect(&bmp);
1952 ok(bm != 0, "CreateBitmapIndirect error %u\n", GetLastError());
1953 test_mono_1x1_bmp(bm);
1954 DeleteObject(bm);
1955
1956 /* Test how the bmBitsPixel field is treated */
1957 for(i = 1; i <= 33; i++) {
1958 bmp.bmType = 0;
1959 bmp.bmWidth = 1;
1960 bmp.bmHeight = 1;
1961 bmp.bmWidthBytes = 28;
1962 bmp.bmPlanes = 1;
1963 bmp.bmBitsPixel = i;
1964 bmp.bmBits = NULL;
1965 SetLastError(0xdeadbeef);
1966 bm = CreateBitmapIndirect(&bmp);
1967 if(i > 32) {
1968 DWORD error = GetLastError();
1969 ok(bm == 0 ||
1970 broken(bm != 0), /* Win9x and WinMe */
1971 "CreateBitmapIndirect for %d bpp succeeded\n", i);
1972 ok(error == ERROR_INVALID_PARAMETER ||
1973 broken(error == 0xdeadbeef), /* Win9x and WinME */
1974 "Got error %d, expected ERROR_INVALID_PARAMETER\n", error);
1975 DeleteObject(bm);
1976 continue;
1977 }
1978 ok(bm != 0, "CreateBitmapIndirect error %u\n", GetLastError());
1979 GetObject(bm, sizeof(bmp), &bmp);
1980 if(i == 1) {
1981 expect = 1;
1982 } else if(i <= 4) {
1983 expect = 4;
1984 } else if(i <= 8) {
1985 expect = 8;
1986 } else if(i <= 16) {
1987 expect = 16;
1988 } else if(i <= 24) {
1989 expect = 24;
1990 } else if(i <= 32) {
1991 expect = 32;
1992 }
1993 ok(bmp.bmBitsPixel == expect ||
1994 broken(bmp.bmBitsPixel == i), /* Win9x and WinMe */
1995 "CreateBitmapIndirect for a %d bpp bitmap created a %d bpp bitmap, expected %d\n",
1996 i, bmp.bmBitsPixel, expect);
1997 DeleteObject(bm);
1998 }
1999 }
2000
2001 static void test_bitmapinfoheadersize(void)
2002 {
2003 HBITMAP hdib;
2004 BITMAPINFO bmi;
2005 BITMAPCOREINFO bci;
2006 HDC hdc = GetDC(0);
2007
2008 memset(&bmi, 0, sizeof(BITMAPINFO));
2009 bmi.bmiHeader.biHeight = 100;
2010 bmi.bmiHeader.biWidth = 512;
2011 bmi.bmiHeader.biBitCount = 24;
2012 bmi.bmiHeader.biPlanes = 1;
2013
2014 bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER) - 1;
2015
2016 hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
2017 ok(hdib == NULL, "CreateDIBSection succeeded\n");
2018
2019 bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2020
2021 SetLastError(0xdeadbeef);
2022 hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
2023 ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
2024 DeleteObject(hdib);
2025
2026 bmi.bmiHeader.biSize++;
2027
2028 SetLastError(0xdeadbeef);
2029 hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
2030 ok(hdib != NULL ||
2031 broken(!hdib), /* Win98, WinMe */
2032 "CreateDIBSection error %d\n", GetLastError());
2033 DeleteObject(hdib);
2034
2035 bmi.bmiHeader.biSize = sizeof(BITMAPINFO);
2036
2037 SetLastError(0xdeadbeef);
2038 hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
2039 ok(hdib != NULL ||
2040 broken(!hdib), /* Win98, WinMe */
2041 "CreateDIBSection error %d\n", GetLastError());
2042 DeleteObject(hdib);
2043
2044 bmi.bmiHeader.biSize++;
2045
2046 SetLastError(0xdeadbeef);
2047 hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
2048 ok(hdib != NULL ||
2049 broken(!hdib), /* Win98, WinMe */
2050 "CreateDIBSection error %d\n", GetLastError());
2051 DeleteObject(hdib);
2052
2053 bmi.bmiHeader.biSize = sizeof(BITMAPV4HEADER);
2054
2055 SetLastError(0xdeadbeef);
2056 hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
2057 ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
2058 DeleteObject(hdib);
2059
2060 bmi.bmiHeader.biSize = sizeof(BITMAPV5HEADER);
2061
2062 SetLastError(0xdeadbeef);
2063 hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
2064 ok(hdib != NULL ||
2065 broken(!hdib), /* Win95 */
2066 "CreateDIBSection error %d\n", GetLastError());
2067 DeleteObject(hdib);
2068
2069 memset(&bci, 0, sizeof(BITMAPCOREINFO));
2070 bci.bmciHeader.bcHeight = 100;
2071 bci.bmciHeader.bcWidth = 512;
2072 bci.bmciHeader.bcBitCount = 24;
2073 bci.bmciHeader.bcPlanes = 1;
2074
2075 bci.bmciHeader.bcSize = sizeof(BITMAPCOREHEADER) - 1;
2076
2077 hdib = CreateDIBSection(hdc, (BITMAPINFO *)&bci, 0, NULL, NULL, 0);
2078 ok(hdib == NULL, "CreateDIBSection succeeded\n");
2079
2080 bci.bmciHeader.bcSize = sizeof(BITMAPCOREHEADER);
2081
2082 SetLastError(0xdeadbeef);
2083 hdib = CreateDIBSection(hdc, (BITMAPINFO *)&bci, 0, NULL, NULL, 0);
2084 ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
2085 DeleteObject(hdib);
2086
2087 bci.bmciHeader.bcSize++;
2088
2089 hdib = CreateDIBSection(hdc, (BITMAPINFO *)&bci, 0, NULL, NULL, 0);
2090 ok(hdib == NULL, "CreateDIBSection succeeded\n");
2091
2092 bci.bmciHeader.bcSize = sizeof(BITMAPCOREINFO);
2093
2094 hdib = CreateDIBSection(hdc, (BITMAPINFO *)&bci, 0, NULL, NULL, 0);
2095 ok(hdib == NULL, "CreateDIBSection succeeded\n");
2096
2097 ReleaseDC(0, hdc);
2098 }
2099
2100 static void test_get16dibits(void)
2101 {
2102 BYTE bits[4 * (16 / sizeof(BYTE))];
2103 HBITMAP hbmp;
2104 HDC screen_dc = GetDC(NULL);
2105 int ret;
2106 BITMAPINFO * info;
2107 int info_len = sizeof(BITMAPINFOHEADER) + 1024;
2108 BYTE *p;
2109 int overwritten_bytes = 0;
2110
2111 memset(bits, 0, sizeof(bits));
2112 hbmp = CreateBitmap(2, 2, 1, 16, bits);
2113 ok(hbmp != NULL, "CreateBitmap failed\n");
2114
2115 info = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, info_len);
2116 assert(info);
2117
2118 memset(info, '!', info_len);
2119 memset(info, 0, sizeof(info->bmiHeader));
2120
2121 info->bmiHeader.biSize = sizeof(info->bmiHeader);
2122 info->bmiHeader.biWidth = 2;
2123 info->bmiHeader.biHeight = 2;
2124 info->bmiHeader.biPlanes = 1;
2125 info->bmiHeader.biCompression = BI_RGB;
2126
2127 ret = GetDIBits(screen_dc, hbmp, 0, 0, NULL, info, 0);
2128 ok(ret != 0, "GetDIBits failed\n");
2129
2130 for (p = ((BYTE *) info) + sizeof(info->bmiHeader); (p - ((BYTE *) info)) < info_len; p++)
2131 if (*p != '!')
2132 overwritten_bytes++;
2133 ok(overwritten_bytes == 0, "GetDIBits wrote past the buffer given\n");
2134
2135 HeapFree(GetProcessHeap(), 0, info);
2136 DeleteObject(hbmp);
2137 ReleaseDC(NULL, screen_dc);
2138 }
2139
2140 static void test_GdiAlphaBlend(void)
2141 {
2142 /* test out-of-bound parameters for GdiAlphaBlend */
2143 HDC hdcNull;
2144
2145 HDC hdcDst;
2146 HBITMAP bmpDst;
2147 HBITMAP oldDst;
2148
2149 BITMAPINFO bmi;
2150 HDC hdcSrc;
2151 HBITMAP bmpSrc;
2152 HBITMAP oldSrc;
2153 LPVOID bits;
2154
2155 BLENDFUNCTION blend;
2156
2157 if (!pGdiAlphaBlend)
2158 {
2159 win_skip("GdiAlphaBlend() is not implemented\n");
2160 return;
2161 }
2162
2163 hdcNull = GetDC(NULL);
2164 hdcDst = CreateCompatibleDC(hdcNull);
2165 bmpDst = CreateCompatibleBitmap(hdcNull, 100, 100);
2166 hdcSrc = CreateCompatibleDC(hdcNull);
2167
2168 memset(&bmi, 0, sizeof(bmi)); /* as of Wine 0.9.44 we require the src to be a DIB section */
2169 bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
2170 bmi.bmiHeader.biHeight = 20;
2171 bmi.bmiHeader.biWidth = 20;
2172 bmi.bmiHeader.biBitCount = 32;
2173 bmi.bmiHeader.biPlanes = 1;
2174 bmi.bmiHeader.biCompression = BI_RGB;
2175 bmpSrc = CreateDIBSection(hdcDst, &bmi, DIB_RGB_COLORS, &bits, NULL, 0);
2176 ok(bmpSrc != NULL, "Couldn't create source bitmap\n");
2177
2178 oldDst = SelectObject(hdcDst, bmpDst);
2179 oldSrc = SelectObject(hdcSrc, bmpSrc);
2180
2181 blend.BlendOp = AC_SRC_OVER;
2182 blend.BlendFlags = 0;
2183 blend.SourceConstantAlpha = 128;
2184 blend.AlphaFormat = 0;
2185
2186 expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, 0, 0, 20, 20, blend), TRUE, BOOL, "%d");
2187 SetLastError(0xdeadbeef);
2188 expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, -1, 0, 10, 10, blend), FALSE, BOOL, "%d");
2189 expect_eq(GetLastError(), ERROR_INVALID_PARAMETER, int, "%d");
2190 expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, 0, -1, 10, 10, blend), FALSE, BOOL, "%d");
2191 expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, 15, 0, 10, 10, blend), FALSE, BOOL, "%d");
2192 expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, 10, 10, -2, 3, blend), FALSE, BOOL, "%d");
2193 expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, 10, 10, -2, 3, blend), FALSE, BOOL, "%d");
2194
2195 SetWindowOrgEx(hdcSrc, -10, -10, NULL);
2196 expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, -1, 0, 10, 10, blend), TRUE, BOOL, "%d");
2197 expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, 0, -1, 10, 10, blend), TRUE, BOOL, "%d");
2198 SetMapMode(hdcSrc, MM_ANISOTROPIC);
2199 ScaleWindowExtEx(hdcSrc, 10, 1, 10, 1, NULL);
2200 expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, -1, 0, 30, 30, blend), TRUE, BOOL, "%d");
2201 expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, 0, -1, 30, 30, blend), TRUE, BOOL, "%d");
2202
2203 SelectObject(hdcDst, oldDst);
2204 SelectObject(hdcSrc, oldSrc);
2205 DeleteObject(bmpSrc);
2206 DeleteObject(bmpDst);
2207 DeleteDC(hdcDst);
2208 DeleteDC(hdcSrc);
2209
2210 ReleaseDC(NULL, hdcNull);
2211
2212 }
2213
2214 static void test_clipping(void)
2215 {
2216 HBITMAP bmpDst;
2217 HBITMAP oldDst;
2218 HBITMAP bmpSrc;
2219 HBITMAP oldSrc;
2220 HRGN hRgn;
2221 LPVOID bits;
2222 BOOL result;
2223
2224 HDC hdcDst = CreateCompatibleDC( NULL );
2225 HDC hdcSrc = CreateCompatibleDC( NULL );
2226
2227 BITMAPINFO bmpinfo={{0}};
2228 bmpinfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2229 bmpinfo.bmiHeader.biWidth = 100;
2230 bmpinfo.bmiHeader.biHeight = 100;
2231 bmpinfo.bmiHeader.biPlanes = 1;
2232 bmpinfo.bmiHeader.biBitCount = GetDeviceCaps( hdcDst, BITSPIXEL );
2233 bmpinfo.bmiHeader.biCompression = BI_RGB;
2234
2235 bmpDst = CreateDIBSection( hdcDst, &bmpinfo, DIB_RGB_COLORS, &bits, NULL, 0 );
2236 ok(bmpDst != NULL, "Couldn't create destination bitmap\n");
2237 oldDst = SelectObject( hdcDst, bmpDst );
2238
2239 bmpSrc = CreateDIBSection( hdcSrc, &bmpinfo, DIB_RGB_COLORS, &bits, NULL, 0 );
2240 ok(bmpSrc != NULL, "Couldn't create source bitmap\n");
2241 oldSrc = SelectObject( hdcSrc, bmpSrc );
2242
2243 result = BitBlt( hdcDst, 0, 0, 100, 100, hdcSrc, 100, 100, SRCCOPY );
2244 ok(result, "BitBlt failed\n");
2245
2246 hRgn = CreateRectRgn( 0,0,0,0 );
2247 SelectClipRgn( hdcDst, hRgn );
2248
2249 result = BitBlt( hdcDst, 0, 0, 100, 100, hdcSrc, 0, 0, SRCCOPY );
2250 ok(result, "BitBlt failed\n");
2251
2252 DeleteObject( bmpDst );
2253 DeleteObject( bmpSrc );
2254 DeleteObject( hRgn );
2255 DeleteDC( hdcDst );
2256 DeleteDC( hdcSrc );
2257 }
2258
2259 START_TEST(bitmap)
2260 {
2261 HMODULE hdll;
2262 is_win9x = GetWindowLongPtrW(GetDesktopWindow(), GWLP_WNDPROC) == 0;
2263
2264 hdll = GetModuleHandle("gdi32.dll");
2265 pGdiAlphaBlend = (void*)GetProcAddress(hdll, "GdiAlphaBlend");
2266
2267 test_createdibitmap();
2268 test_dibsections();
2269 test_mono_dibsection();
2270 test_bitmap();
2271 test_bmBits();
2272 test_GetDIBits_selected_DIB(1);
2273 test_GetDIBits_selected_DIB(4);
2274 test_GetDIBits_selected_DIB(8);
2275 test_GetDIBits_selected_DDB(TRUE);
2276 test_GetDIBits_selected_DDB(FALSE);
2277 test_GetDIBits();
2278 test_GetDIBits_BI_BITFIELDS();
2279 test_select_object();
2280 test_CreateBitmap();
2281 test_GdiAlphaBlend();
2282 test_bitmapinfoheadersize();
2283 test_get16dibits();
2284 test_clipping();
2285 }
Quick hack tree for wine patches julliard doesn't want to commit