git.oblomov.eu Git - wine/blob - dlls/gdi32/tests/bitmap.c

   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 static DWORD (WINAPI *pSetLayout)(HDC hdc, DWORD layout);
  37
  38 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
  39
  40 static INT BITMAP_GetWidthBytes( INT bmWidth, INT bpp )
  41 {
  42     switch(bpp)
  43     {
  44     case 1:
  45         return 2 * ((bmWidth+15) >> 4);
  46
  47     case 24:
  48         bmWidth *= 3; /* fall through */
  49     case 8:
  50         return bmWidth + (bmWidth & 1);
  51
  52     case 32:
  53         return bmWidth * 4;
  54
  55     case 16:
  56     case 15:
  57         return bmWidth * 2;
  58
  59     case 4:
  60         return 2 * ((bmWidth+3) >> 2);
  61
  62     default:
  63         trace("Unknown depth %d, please report.\n", bpp );
  64         assert(0);
  65     }
  66     return -1;
  67 }
  68
  69 static void test_bitmap_info(HBITMAP hbm, INT expected_depth, const BITMAPINFOHEADER *bmih)
  70 {
  71     BITMAP bm;
  72     BITMAP bma[2];
  73     INT ret, width_bytes;
  74     BYTE buf[512], buf_cmp[512];
  75
  76     ret = GetObject(hbm, sizeof(bm), &bm);
  77     ok(ret == sizeof(bm), "GetObject returned %d\n", ret);
  78
  79     ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
  80     ok(bm.bmWidth == bmih->biWidth, "wrong bm.bmWidth %d\n", bm.bmWidth);
  81     ok(bm.bmHeight == bmih->biHeight, "wrong bm.bmHeight %d\n", bm.bmHeight);
  82     width_bytes = BITMAP_GetWidthBytes(bm.bmWidth, bm.bmBitsPixel);
  83     ok(bm.bmWidthBytes == width_bytes, "wrong bm.bmWidthBytes %d != %d\n", bm.bmWidthBytes, width_bytes);
  84     ok(bm.bmPlanes == bmih->biPlanes, "wrong bm.bmPlanes %d\n", bm.bmPlanes);
  85     ok(bm.bmBitsPixel == expected_depth, "wrong bm.bmBitsPixel %d != %d\n", bm.bmBitsPixel, expected_depth);
  86     ok(bm.bmBits == NULL, "wrong bm.bmBits %p\n", bm.bmBits);
  87
  88     assert(sizeof(buf) >= bm.bmWidthBytes * bm.bmHeight);
  89     assert(sizeof(buf) == sizeof(buf_cmp));
  90
  91     SetLastError(0xdeadbeef);
  92     ret = GetBitmapBits(hbm, 0, NULL);
  93     ok(ret == bm.bmWidthBytes * bm.bmHeight, "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
  94
  95     memset(buf_cmp, 0xAA, sizeof(buf_cmp));
  96     memset(buf_cmp, 0, bm.bmWidthBytes * bm.bmHeight);
  97
  98     memset(buf, 0xAA, sizeof(buf));
  99     ret = GetBitmapBits(hbm, sizeof(buf), buf);
 100     ok(ret == bm.bmWidthBytes * bm.bmHeight, "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
 101     ok(!memcmp(buf, buf_cmp, sizeof(buf)),
 102         "buffers do not match, depth %d\n", bmih->biBitCount);
 103
 104     /* test various buffer sizes for GetObject */
 105     ret = GetObject(hbm, sizeof(*bma) * 2, bma);
 106     ok(ret == sizeof(*bma), "wrong size %d\n", ret);
 107
 108     ret = GetObject(hbm, sizeof(bm) / 2, &bm);
 109     ok(ret == 0, "%d != 0\n", ret);
 110
 111     ret = GetObject(hbm, 0, &bm);
 112     ok(ret == 0, "%d != 0\n", ret);
 113
 114     ret = GetObject(hbm, 1, &bm);
 115     ok(ret == 0, "%d != 0\n", ret);
 116
 117     ret = GetObject(hbm, 0, NULL);
 118     ok(ret == sizeof(bm), "wrong size %d\n", ret);
 119 }
 120
 121 static void test_createdibitmap(void)
 122 {
 123     HDC hdc, hdcmem;
 124     BITMAPINFOHEADER bmih;
 125     BITMAPINFO bm;
 126     HBITMAP hbm, hbm_colour, hbm_old;
 127     INT screen_depth;
 128     DWORD pixel;
 129
 130     hdc = GetDC(0);
 131     screen_depth = GetDeviceCaps(hdc, BITSPIXEL);
 132     memset(&bmih, 0, sizeof(bmih));
 133     bmih.biSize = sizeof(bmih);
 134     bmih.biWidth = 10;
 135     bmih.biHeight = 10;
 136     bmih.biPlanes = 1;
 137     bmih.biBitCount = 32;
 138     bmih.biCompression = BI_RGB;
 139
 140     hbm = CreateDIBitmap(hdc, NULL, CBM_INIT, NULL, NULL, 0);
 141     ok(hbm == NULL, "CreateDIBitmap should fail\n");
 142     hbm = CreateDIBitmap(hdc, NULL, 0, NULL, NULL, 0);
 143     ok(hbm == NULL, "CreateDIBitmap should fail\n");
 144
 145     /* First create an un-initialised bitmap.  The depth of the bitmap
 146        should match that of the hdc and not that supplied in bmih.
 147     */
 148
 149     /* First try 32 bits */
 150     hbm = CreateDIBitmap(hdc, &bmih, 0, NULL, NULL, 0);
 151     ok(hbm != NULL, "CreateDIBitmap failed\n");
 152     test_bitmap_info(hbm, screen_depth, &bmih);
 153     DeleteObject(hbm);
 154
 155     /* Then 16 */
 156     bmih.biBitCount = 16;
 157     hbm = CreateDIBitmap(hdc, &bmih, 0, NULL, NULL, 0);
 158     ok(hbm != NULL, "CreateDIBitmap failed\n");
 159     test_bitmap_info(hbm, screen_depth, &bmih);
 160     DeleteObject(hbm);
 161
 162     /* Then 1 */
 163     bmih.biBitCount = 1;
 164     hbm = CreateDIBitmap(hdc, &bmih, 0, NULL, NULL, 0);
 165     ok(hbm != NULL, "CreateDIBitmap failed\n");
 166     test_bitmap_info(hbm, screen_depth, &bmih);
 167     DeleteObject(hbm);
 168
 169     /* Now with a monochrome dc we expect a monochrome bitmap */
 170     hdcmem = CreateCompatibleDC(hdc);
 171
 172     /* First try 32 bits */
 173     bmih.biBitCount = 32;
 174     hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
 175     ok(hbm != NULL, "CreateDIBitmap failed\n");
 176     test_bitmap_info(hbm, 1, &bmih);
 177     DeleteObject(hbm);
 178
 179     /* Then 16 */
 180     bmih.biBitCount = 16;
 181     hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
 182     ok(hbm != NULL, "CreateDIBitmap failed\n");
 183     test_bitmap_info(hbm, 1, &bmih);
 184     DeleteObject(hbm);
 185
 186     /* Then 1 */
 187     bmih.biBitCount = 1;
 188     hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
 189     ok(hbm != NULL, "CreateDIBitmap failed\n");
 190     test_bitmap_info(hbm, 1, &bmih);
 191     DeleteObject(hbm);
 192
 193     /* Now select a polychrome bitmap into the dc and we expect
 194        screen_depth bitmaps again */
 195     hbm_colour = CreateCompatibleBitmap(hdc, bmih.biWidth, bmih.biHeight);
 196     test_bitmap_info(hbm_colour, screen_depth, &bmih);
 197     hbm_old = SelectObject(hdcmem, hbm_colour);
 198
 199     /* First try 32 bits */
 200     bmih.biBitCount = 32;
 201     hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
 202     ok(hbm != NULL, "CreateDIBitmap failed\n");
 203     test_bitmap_info(hbm, screen_depth, &bmih);
 204     DeleteObject(hbm);
 205
 206     /* Then 16 */
 207     bmih.biBitCount = 16;
 208     hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
 209     ok(hbm != NULL, "CreateDIBitmap failed\n");
 210     test_bitmap_info(hbm, screen_depth, &bmih);
 211     DeleteObject(hbm);
 212
 213     /* Then 1 */
 214     bmih.biBitCount = 1;
 215     hbm = CreateDIBitmap(hdcmem, &bmih, 0, NULL, NULL, 0);
 216     ok(hbm != NULL, "CreateDIBitmap failed\n");
 217     test_bitmap_info(hbm, screen_depth, &bmih);
 218     DeleteObject(hbm);
 219
 220     SelectObject(hdcmem, hbm_old);
 221     DeleteObject(hbm_colour);
 222     DeleteDC(hdcmem);
 223
 224     bmih.biBitCount = 32;
 225     hbm = CreateDIBitmap(0, &bmih, 0, NULL, NULL, 0);
 226     ok(hbm != NULL, "CreateDIBitmap failed\n");
 227     test_bitmap_info(hbm, 1, &bmih);
 228     DeleteObject(hbm);
 229
 230     /* Test how formats are converted */
 231     pixel = 0xffffffff;
 232     bmih.biBitCount = 1;
 233     bmih.biWidth = 1;
 234     bmih.biHeight = 1;
 235
 236     memset(&bm, 0, sizeof(bm));
 237     bm.bmiHeader.biSize = sizeof(bm.bmiHeader);
 238     bm.bmiHeader.biWidth = 1;
 239     bm.bmiHeader.biHeight = 1;
 240     bm.bmiHeader.biPlanes = 1;
 241     bm.bmiHeader.biBitCount= 24;
 242     bm.bmiHeader.biCompression= BI_RGB;
 243     bm.bmiHeader.biSizeImage = 0;
 244     hbm = CreateDIBitmap(hdc, &bmih, CBM_INIT, &pixel, &bm, DIB_RGB_COLORS);
 245     ok(hbm != NULL, "CreateDIBitmap failed\n");
 246
 247     pixel = 0xdeadbeef;
 248     bm.bmiHeader.biBitCount= 32;
 249     GetDIBits(hdc, hbm, 0, 1, &pixel, &bm, DIB_RGB_COLORS);
 250     ok(pixel == 0x00ffffff, "Reading a 32 bit pixel from a DDB returned %08x\n", pixel);
 251     DeleteObject(hbm);
 252
 253     ReleaseDC(0, hdc);
 254 }
 255
 256 static INT DIB_GetWidthBytes( int width, int bpp )
 257 {
 258     int words;
 259
 260     switch (bpp)
 261     {
 262         case 1:  words = (width + 31) / 32; break;
 263         case 4:  words = (width + 7) / 8; break;
 264         case 8:  words = (width + 3) / 4; break;
 265         case 15:
 266         case 16: words = (width + 1) / 2; break;
 267         case 24: words = (width * 3 + 3)/4; break;
 268         case 32: words = width; break;
 269
 270         default:
 271             words=0;
 272             trace("Unknown depth %d, please report.\n", bpp );
 273             assert(0);
 274             break;
 275     }
 276     return 4 * words;
 277 }
 278
 279 static void test_dib_info(HBITMAP hbm, const void *bits, const BITMAPINFOHEADER *bmih)
 280 {
 281     BITMAP bm;
 282     BITMAP bma[2];
 283     DIBSECTION ds;
 284     DIBSECTION dsa[2];
 285     INT ret, bm_width_bytes, dib_width_bytes;
 286     BYTE *buf;
 287
 288     ret = GetObject(hbm, sizeof(bm), &bm);
 289     ok(ret == sizeof(bm), "GetObject returned %d\n", ret);
 290
 291     ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
 292     ok(bm.bmWidth == bmih->biWidth, "wrong bm.bmWidth %d\n", bm.bmWidth);
 293     ok(bm.bmHeight == abs(bmih->biHeight), "wrong bm.bmHeight %d\n", bm.bmHeight);
 294     dib_width_bytes = DIB_GetWidthBytes(bm.bmWidth, bm.bmBitsPixel);
 295     bm_width_bytes = BITMAP_GetWidthBytes(bm.bmWidth, bm.bmBitsPixel);
 296     if (bm.bmWidthBytes != dib_width_bytes) /* Win2k bug */
 297         ok(bm.bmWidthBytes == bm_width_bytes, "wrong bm.bmWidthBytes %d != %d\n", bm.bmWidthBytes, bm_width_bytes);
 298     else
 299         ok(bm.bmWidthBytes == dib_width_bytes, "wrong bm.bmWidthBytes %d != %d\n", bm.bmWidthBytes, dib_width_bytes);
 300     ok(bm.bmPlanes == bmih->biPlanes, "wrong bm.bmPlanes %d\n", bm.bmPlanes);
 301     ok(bm.bmBitsPixel == bmih->biBitCount, "bm.bmBitsPixel %d != %d\n", bm.bmBitsPixel, bmih->biBitCount);
 302     ok(bm.bmBits == bits, "wrong bm.bmBits %p != %p\n", bm.bmBits, bits);
 303
 304     buf = HeapAlloc(GetProcessHeap(), 0, bm.bmWidthBytes * bm.bmHeight + 4096);
 305
 306     /* GetBitmapBits returns not 32-bit aligned data */
 307     SetLastError(0xdeadbeef);
 308     ret = GetBitmapBits(hbm, 0, NULL);
 309     ok(ret == bm_width_bytes * bm.bmHeight,
 310         "%d != %d\n", ret, bm_width_bytes * bm.bmHeight);
 311
 312     memset(buf, 0xAA, bm.bmWidthBytes * bm.bmHeight + 4096);
 313     ret = GetBitmapBits(hbm, bm.bmWidthBytes * bm.bmHeight + 4096, buf);
 314     ok(ret == bm_width_bytes * bm.bmHeight, "%d != %d\n", ret, bm_width_bytes * bm.bmHeight);
 315
 316     HeapFree(GetProcessHeap(), 0, buf);
 317
 318     /* test various buffer sizes for GetObject */
 319     memset(&ds, 0xAA, sizeof(ds));
 320     ret = GetObject(hbm, sizeof(*bma) * 2, bma);
 321     ok(ret == sizeof(*bma), "wrong size %d\n", ret);
 322     ok(bm.bmWidth == bmih->biWidth, "wrong bm.bmWidth %d\n", bm.bmWidth);
 323     ok(bm.bmHeight == abs(bmih->biHeight), "wrong bm.bmHeight %d\n", bm.bmHeight);
 324     ok(bm.bmBits == bits, "wrong bm.bmBits %p != %p\n", bm.bmBits, bits);
 325
 326     ret = GetObject(hbm, sizeof(bm) / 2, &bm);
 327     ok(ret == 0, "%d != 0\n", ret);
 328
 329     ret = GetObject(hbm, 0, &bm);
 330     ok(ret == 0, "%d != 0\n", ret);
 331
 332     ret = GetObject(hbm, 1, &bm);
 333     ok(ret == 0, "%d != 0\n", ret);
 334
 335     /* test various buffer sizes for GetObject */
 336     ret = GetObject(hbm, 0, NULL);
 337     ok(ret == sizeof(bm), "wrong size %d\n", ret);
 338
 339     ret = GetObject(hbm, sizeof(*dsa) * 2, dsa);
 340     ok(ret == sizeof(*dsa), "wrong size %d\n", ret);
 341
 342     memset(&ds, 0xAA, sizeof(ds));
 343     ret = GetObject(hbm, sizeof(ds), &ds);
 344     ok(ret == sizeof(ds), "wrong size %d\n", ret);
 345
 346     ok(ds.dsBm.bmBits == bits, "wrong bm.bmBits %p != %p\n", ds.dsBm.bmBits, bits);
 347     if (ds.dsBm.bmWidthBytes != bm_width_bytes) /* Win2k bug */
 348         ok(ds.dsBmih.biSizeImage == ds.dsBm.bmWidthBytes * ds.dsBm.bmHeight, "%u != %u\n",
 349            ds.dsBmih.biSizeImage, ds.dsBm.bmWidthBytes * ds.dsBm.bmHeight);
 350     ok(bmih->biSizeImage == 0, "%u != 0\n", bmih->biSizeImage);
 351     ds.dsBmih.biSizeImage = 0;
 352
 353     ok(ds.dsBmih.biSize == bmih->biSize, "%u != %u\n", ds.dsBmih.biSize, bmih->biSize);
 354     ok(ds.dsBmih.biWidth == bmih->biWidth, "%d != %d\n", ds.dsBmih.biWidth, bmih->biWidth);
 355     ok(ds.dsBmih.biHeight == abs(bmih->biHeight), "%d != %d\n", ds.dsBmih.biHeight, abs(bmih->biHeight));
 356     ok(ds.dsBmih.biPlanes == bmih->biPlanes, "%u != %u\n", ds.dsBmih.biPlanes, bmih->biPlanes);
 357     ok(ds.dsBmih.biBitCount == bmih->biBitCount, "%u != %u\n", ds.dsBmih.biBitCount, bmih->biBitCount);
 358     ok(ds.dsBmih.biCompression == bmih->biCompression ||
 359        ((bmih->biBitCount == 32) && broken(ds.dsBmih.biCompression == BI_BITFIELDS)), /* nt4 sp1 and 2 */
 360        "%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, "%d != %d\n", ds.dsBmih.biXPelsPerMeter, bmih->biXPelsPerMeter);
 363     ok(ds.dsBmih.biYPelsPerMeter == bmih->biYPelsPerMeter, "%d != %d\n", ds.dsBmih.biYPelsPerMeter, bmih->biYPelsPerMeter);
 364
 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, "%d != %d\n", ds.dsBmih.biWidth, bmih->biWidth);
 369     ok(ds.dsBm.bmHeight == abs(bmih->biHeight), "%d != %d\n", ds.dsBmih.biHeight, abs(bmih->biHeight));
 370     ok(ds.dsBm.bmBits == bits, "%p != %p\n", ds.dsBm.bmBits, bits);
 371
 372     ret = GetObject(hbm, 0, &ds);
 373     ok(ret == 0, "%d != 0\n", ret);
 374
 375     ret = GetObject(hbm, 1, &ds);
 376     ok(ret == 0, "%d != 0\n", ret);
 377 }
 378
 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); \
 383       return; \
 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) \
 386
 387 #define test_color(hdc, color, exp, todo_setp, todo_getp) \
 388 { \
 389     COLORREF c; \
 390     c = SetPixel(hdc, 0, 0, color); \
 391     test_color_todo(c, exp, SetPixel, todo_setp); \
 392     c = GetPixel(hdc, 0, 0); \
 393     test_color_todo(c, exp, GetPixel, todo_getp); \
 394 }
 395
 396 static void test_dib_bits_access( HBITMAP hdib, void *bits )
 397 {
 398     MEMORY_BASIC_INFORMATION info;
 399     char bmibuf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)];
 400     DWORD data[256];
 401     BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
 402     HDC hdc;
 403     char filename[MAX_PATH];
 404     HANDLE file;
 405     DWORD written;
 406     INT ret;
 407
 408     ok(VirtualQuery(bits, &info, sizeof(info)) == sizeof(info),
 409         "VirtualQuery failed\n");
 410     ok(info.BaseAddress == bits, "%p != %p\n", info.BaseAddress, bits);
 411     ok(info.AllocationBase == bits, "%p != %p\n", info.AllocationBase, bits);
 412     ok(info.AllocationProtect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.AllocationProtect);
 413     ok(info.State == MEM_COMMIT, "%x != MEM_COMMIT\n", info.State);
 414     ok(info.Protect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.Protect);
 415     ok(info.Type == MEM_PRIVATE, "%x != MEM_PRIVATE\n", info.Type);
 416
 417     memset( pbmi, 0, sizeof(bmibuf) );
 418     memset( data, 0xcc, sizeof(data) );
 419     pbmi->bmiHeader.biSize = sizeof(pbmi->bmiHeader);
 420     pbmi->bmiHeader.biHeight = 16;
 421     pbmi->bmiHeader.biWidth = 16;
 422     pbmi->bmiHeader.biBitCount = 32;
 423     pbmi->bmiHeader.biPlanes = 1;
 424     pbmi->bmiHeader.biCompression = BI_RGB;
 425
 426     hdc = GetDC(0);
 427
 428     ret = SetDIBits( hdc, hdib, 0, 16, data, pbmi, DIB_RGB_COLORS );
 429     ok(ret == 16, "SetDIBits failed: expected 16 got %d\n", ret);
 430
 431     ReleaseDC(0, hdc);
 432
 433     ok(VirtualQuery(bits, &info, sizeof(info)) == sizeof(info),
 434         "VirtualQuery failed\n");
 435     ok(info.BaseAddress == bits, "%p != %p\n", info.BaseAddress, bits);
 436     ok(info.AllocationBase == bits, "%p != %p\n", info.AllocationBase, bits);
 437     ok(info.AllocationProtect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.AllocationProtect);
 438     ok(info.State == MEM_COMMIT, "%x != MEM_COMMIT\n", info.State);
 439     ok(info.Type == MEM_PRIVATE, "%x != MEM_PRIVATE\n", info.Type);
 440     ok(info.Protect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.Protect);
 441
 442     /* try writing protected bits to a file */
 443
 444     GetTempFileNameA( ".", "dib", 0, filename );
 445     file = CreateFileA( filename, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
 446                         CREATE_ALWAYS, 0, 0 );
 447     ok( file != INVALID_HANDLE_VALUE, "failed to open %s error %u\n", filename, GetLastError() );
 448     ret = WriteFile( file, bits, 8192, &written, NULL );
 449     ok( ret, "WriteFile failed error %u\n", GetLastError() );
 450     if (ret) ok( written == 8192, "only wrote %u bytes\n", written );
 451     CloseHandle( file );
 452     DeleteFileA( filename );
 453 }
 454
 455 static void test_dibsections(void)
 456 {
 457     HDC hdc, hdcmem, hdcmem2;
 458     HBITMAP hdib, oldbm, hdib2, oldbm2;
 459     char bmibuf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)];
 460     char bcibuf[sizeof(BITMAPCOREINFO) + 256 * sizeof(RGBTRIPLE)];
 461     BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
 462     BITMAPCOREINFO *pbci = (BITMAPCOREINFO *)bcibuf;
 463     HBITMAP hcoredib;
 464     char coreBits[256];
 465     BYTE *bits;
 466     RGBQUAD rgb[256];
 467     int ret;
 468     char logpalbuf[sizeof(LOGPALETTE) + 256 * sizeof(PALETTEENTRY)];
 469     LOGPALETTE *plogpal = (LOGPALETTE*)logpalbuf;
 470     WORD *index;
 471     DWORD *bits32;
 472     HPALETTE hpal, oldpal;
 473     DIBSECTION dibsec;
 474     COLORREF c0, c1;
 475     int i;
 476     int screen_depth;
 477     MEMORY_BASIC_INFORMATION info;
 478
 479     hdc = GetDC(0);
 480     screen_depth = GetDeviceCaps(hdc, BITSPIXEL) * GetDeviceCaps(hdc, PLANES);
 481
 482     memset(pbmi, 0, sizeof(bmibuf));
 483     pbmi->bmiHeader.biSize = sizeof(pbmi->bmiHeader);
 484     pbmi->bmiHeader.biHeight = 100;
 485     pbmi->bmiHeader.biWidth = 512;
 486     pbmi->bmiHeader.biBitCount = 24;
 487     pbmi->bmiHeader.biPlanes = 1;
 488     pbmi->bmiHeader.biCompression = BI_RGB;
 489
 490     SetLastError(0xdeadbeef);
 491
 492     /* invalid pointer for BITMAPINFO
 493        (*bits should be NULL on error) */
 494     bits = (BYTE*)0xdeadbeef;
 495     hdib = CreateDIBSection(hdc, NULL, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
 496     ok(hdib == NULL && bits == NULL, "CreateDIBSection failed for invalid parameter: bmi == 0x0\n");
 497
 498     hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
 499     ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
 500     ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIBSection\n");
 501     ok(dibsec.dsBm.bmBits == bits, "dibsec.dsBits %p != bits %p\n", dibsec.dsBm.bmBits, bits);
 502
 503     /* test the DIB memory */
 504     ok(VirtualQuery(bits, &info, sizeof(info)) == sizeof(info),
 505         "VirtualQuery failed\n");
 506     ok(info.BaseAddress == bits, "%p != %p\n", info.BaseAddress, bits);
 507     ok(info.AllocationBase == bits, "%p != %p\n", info.AllocationBase, bits);
 508     ok(info.AllocationProtect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.AllocationProtect);
 509     ok(info.RegionSize == 0x26000, "0x%lx != 0x26000\n", info.RegionSize);
 510     ok(info.State == MEM_COMMIT, "%x != MEM_COMMIT\n", info.State);
 511     ok(info.Protect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.Protect);
 512     ok(info.Type == MEM_PRIVATE, "%x != MEM_PRIVATE\n", info.Type);
 513
 514     test_dib_bits_access( hdib, bits );
 515
 516     test_dib_info(hdib, bits, &pbmi->bmiHeader);
 517     DeleteObject(hdib);
 518
 519     /* Test a top-down DIB. */
 520     pbmi->bmiHeader.biHeight = -100;
 521     hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
 522     ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
 523     test_dib_info(hdib, bits, &pbmi->bmiHeader);
 524     DeleteObject(hdib);
 525
 526     pbmi->bmiHeader.biHeight = 100;
 527     pbmi->bmiHeader.biBitCount = 8;
 528     pbmi->bmiHeader.biCompression = BI_RLE8;
 529     SetLastError(0xdeadbeef);
 530     hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
 531     ok(hdib == NULL, "CreateDIBSection should fail when asked to create a compressed DIB section\n");
 532     ok(GetLastError() == 0xdeadbeef, "wrong error %d\n", GetLastError());
 533
 534     pbmi->bmiHeader.biBitCount = 16;
 535     pbmi->bmiHeader.biCompression = BI_BITFIELDS;
 536     ((PDWORD)pbmi->bmiColors)[0] = 0xf800;
 537     ((PDWORD)pbmi->bmiColors)[1] = 0x07e0;
 538     ((PDWORD)pbmi->bmiColors)[2] = 0x001f;
 539     SetLastError(0xdeadbeef);
 540     hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
 541     ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
 542
 543     /* test the DIB memory */
 544     ok(VirtualQuery(bits, &info, sizeof(info)) == sizeof(info),
 545         "VirtualQuery failed\n");
 546     ok(info.BaseAddress == bits, "%p != %p\n", info.BaseAddress, bits);
 547     ok(info.AllocationBase == bits, "%p != %p\n", info.AllocationBase, bits);
 548     ok(info.AllocationProtect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.AllocationProtect);
 549     ok(info.RegionSize == 0x19000, "0x%lx != 0x19000\n", info.RegionSize);
 550     ok(info.State == MEM_COMMIT, "%x != MEM_COMMIT\n", info.State);
 551     ok(info.Protect == PAGE_READWRITE, "%x != PAGE_READWRITE\n", info.Protect);
 552     ok(info.Type == MEM_PRIVATE, "%x != MEM_PRIVATE\n", info.Type);
 553
 554     test_dib_info(hdib, bits, &pbmi->bmiHeader);
 555     DeleteObject(hdib);
 556
 557     memset(pbmi, 0, sizeof(bmibuf));
 558     pbmi->bmiHeader.biSize = sizeof(pbmi->bmiHeader);
 559     pbmi->bmiHeader.biHeight = 16;
 560     pbmi->bmiHeader.biWidth = 16;
 561     pbmi->bmiHeader.biBitCount = 1;
 562     pbmi->bmiHeader.biPlanes = 1;
 563     pbmi->bmiHeader.biCompression = BI_RGB;
 564     pbmi->bmiColors[0].rgbRed = 0xff;
 565     pbmi->bmiColors[0].rgbGreen = 0;
 566     pbmi->bmiColors[0].rgbBlue = 0;
 567     pbmi->bmiColors[1].rgbRed = 0;
 568     pbmi->bmiColors[1].rgbGreen = 0;
 569     pbmi->bmiColors[1].rgbBlue = 0xff;
 570
 571     hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
 572     ok(hdib != NULL, "CreateDIBSection failed\n");
 573     ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIBSection\n");
 574     ok(dibsec.dsBmih.biClrUsed == 2,
 575         "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 2);
 576
 577     /* Test if the old BITMAPCOREINFO structure is supported */
 578
 579     pbci->bmciHeader.bcSize = sizeof(BITMAPCOREHEADER);
 580     pbci->bmciHeader.bcBitCount = 0;
 581
 582     ret = GetDIBits(hdc, hdib, 0, 16, NULL, (BITMAPINFO*) pbci, DIB_RGB_COLORS);
 583     ok(ret, "GetDIBits doesn't work with a BITMAPCOREHEADER\n");
 584     ok((pbci->bmciHeader.bcWidth == 16) && (pbci->bmciHeader.bcHeight == 16)
 585         && (pbci->bmciHeader.bcBitCount == 1) && (pbci->bmciHeader.bcPlanes == 1),
 586     "GetDIBits didn't fill in the BITMAPCOREHEADER structure properly\n");
 587
 588     ret = GetDIBits(hdc, hdib, 0, 16, &coreBits, (BITMAPINFO*) pbci, DIB_RGB_COLORS);
 589     ok(ret, "GetDIBits doesn't work with a BITMAPCOREHEADER\n");
 590     ok((pbci->bmciColors[0].rgbtRed == 0xff) && (pbci->bmciColors[0].rgbtGreen == 0) &&
 591         (pbci->bmciColors[0].rgbtBlue == 0) && (pbci->bmciColors[1].rgbtRed == 0) &&
 592         (pbci->bmciColors[1].rgbtGreen == 0) && (pbci->bmciColors[1].rgbtBlue == 0xff),
 593         "The color table has not been translated to the old BITMAPCOREINFO format\n");
 594
 595     hcoredib = CreateDIBSection(hdc, (BITMAPINFO*) pbci, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
 596     ok(hcoredib != NULL, "CreateDIBSection failed with a BITMAPCOREINFO\n");
 597
 598     ZeroMemory(pbci->bmciColors, 256 * sizeof(RGBTRIPLE));
 599     ret = GetDIBits(hdc, hcoredib, 0, 16, &coreBits, (BITMAPINFO*) pbci, DIB_RGB_COLORS);
 600     ok(ret, "GetDIBits doesn't work with a BITMAPCOREHEADER\n");
 601     ok((pbci->bmciColors[0].rgbtRed == 0xff) && (pbci->bmciColors[0].rgbtGreen == 0) &&
 602         (pbci->bmciColors[0].rgbtBlue == 0) && (pbci->bmciColors[1].rgbtRed == 0) &&
 603         (pbci->bmciColors[1].rgbtGreen == 0) && (pbci->bmciColors[1].rgbtBlue == 0xff),
 604         "The color table has not been translated to the old BITMAPCOREINFO format\n");
 605
 606     DeleteObject(hcoredib);
 607
 608     hdcmem = CreateCompatibleDC(hdc);
 609     oldbm = SelectObject(hdcmem, hdib);
 610
 611     ret = GetDIBColorTable(hdcmem, 0, 2, rgb);
 612     ok(ret == 2, "GetDIBColorTable returned %d\n", ret);
 613     ok(!memcmp(rgb, pbmi->bmiColors, 2 * sizeof(RGBQUAD)),
 614        "GetDIBColorTable returns table 0: r%02x g%02x b%02x res%02x 1: r%02x g%02x b%02x res%02x\n",
 615        rgb[0].rgbRed, rgb[0].rgbGreen, rgb[0].rgbBlue, rgb[0].rgbReserved,
 616        rgb[1].rgbRed, rgb[1].rgbGreen, rgb[1].rgbBlue, rgb[1].rgbReserved);
 617
 618     c0 = RGB(pbmi->bmiColors[0].rgbRed, pbmi->bmiColors[0].rgbGreen, pbmi->bmiColors[0].rgbBlue);
 619     c1 = RGB(pbmi->bmiColors[1].rgbRed, pbmi->bmiColors[1].rgbGreen, pbmi->bmiColors[1].rgbBlue);
 620
 621     test_color(hdcmem, DIBINDEX(0), c0, 0, 1);
 622     test_color(hdcmem, DIBINDEX(1), c1, 0, 1);
 623     test_color(hdcmem, DIBINDEX(2), c0, 1, 1);
 624     test_color(hdcmem, PALETTEINDEX(0), c0, 1, 1);
 625     test_color(hdcmem, PALETTEINDEX(1), c0, 1, 1);
 626     test_color(hdcmem, PALETTEINDEX(2), c0, 1, 1);
 627     test_color(hdcmem, PALETTERGB(pbmi->bmiColors[0].rgbRed, pbmi->bmiColors[0].rgbGreen,
 628         pbmi->bmiColors[0].rgbBlue), c0, 1, 1);
 629     test_color(hdcmem, PALETTERGB(pbmi->bmiColors[1].rgbRed, pbmi->bmiColors[1].rgbGreen,
 630         pbmi->bmiColors[1].rgbBlue), c1, 1, 1);
 631     test_color(hdcmem, PALETTERGB(0, 0, 0), c0, 1, 1);
 632     test_color(hdcmem, PALETTERGB(0xff, 0xff, 0xff), c0, 1, 1);
 633     test_color(hdcmem, PALETTERGB(0, 0, 0xfe), c1, 1, 1);
 634
 635     SelectObject(hdcmem, oldbm);
 636     DeleteObject(hdib);
 637
 638     pbmi->bmiColors[0].rgbRed = 0xff;
 639     pbmi->bmiColors[0].rgbGreen = 0xff;
 640     pbmi->bmiColors[0].rgbBlue = 0xff;
 641     pbmi->bmiColors[1].rgbRed = 0;
 642     pbmi->bmiColors[1].rgbGreen = 0;
 643     pbmi->bmiColors[1].rgbBlue = 0;
 644
 645     hdib = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
 646     ok(hdib != NULL, "CreateDIBSection failed\n");
 647
 648     test_dib_info(hdib, bits, &pbmi->bmiHeader);
 649
 650     oldbm = SelectObject(hdcmem, hdib);
 651
 652     ret = GetDIBColorTable(hdcmem, 0, 2, rgb);
 653     ok(ret == 2, "GetDIBColorTable returned %d\n", ret);
 654     ok(!memcmp(rgb, pbmi->bmiColors, 2 * sizeof(RGBQUAD)),
 655        "GetDIBColorTable returns table 0: r%02x g%02x b%02x res%02x 1: r%02x g%02x b%02x res%02x\n",
 656        rgb[0].rgbRed, rgb[0].rgbGreen, rgb[0].rgbBlue, rgb[0].rgbReserved,
 657        rgb[1].rgbRed, rgb[1].rgbGreen, rgb[1].rgbBlue, rgb[1].rgbReserved);
 658
 659     SelectObject(hdcmem, oldbm);
 660     test_dib_info(hdib, bits, &pbmi->bmiHeader);
 661     DeleteObject(hdib);
 662
 663     pbmi->bmiHeader.biBitCount = 4;
 664     for (i = 0; i < 16; i++) {
 665         pbmi->bmiColors[i].rgbRed = i;
 666         pbmi->bmiColors[i].rgbGreen = 16-i;
 667         pbmi->bmiColors[i].rgbBlue = 0;
 668     }
 669     hdib = CreateDIBSection(hdcmem, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
 670     ok(hdib != NULL, "CreateDIBSection failed\n");
 671     ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
 672     ok(dibsec.dsBmih.biClrUsed == 16,
 673        "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 16);
 674     test_dib_info(hdib, bits, &pbmi->bmiHeader);
 675     DeleteObject(hdib);
 676
 677     pbmi->bmiHeader.biBitCount = 8;
 678
 679     for (i = 0; i < 128; i++) {
 680         pbmi->bmiColors[i].rgbRed = 255 - i * 2;
 681         pbmi->bmiColors[i].rgbGreen = i * 2;
 682         pbmi->bmiColors[i].rgbBlue = 0;
 683         pbmi->bmiColors[255 - i].rgbRed = 0;
 684         pbmi->bmiColors[255 - i].rgbGreen = i * 2;
 685         pbmi->bmiColors[255 - i].rgbBlue = 255 - i * 2;
 686     }
 687     hdib = CreateDIBSection(hdcmem, pbmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
 688     ok(hdib != NULL, "CreateDIBSection failed\n");
 689     ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
 690     ok(dibsec.dsBmih.biClrUsed == 256,
 691         "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 256);
 692
 693     oldbm = SelectObject(hdcmem, hdib);
 694
 695     for (i = 0; i < 256; i++) {
 696         test_color(hdcmem, DIBINDEX(i),
 697             RGB(pbmi->bmiColors[i].rgbRed, pbmi->bmiColors[i].rgbGreen, pbmi->bmiColors[i].rgbBlue), 0, 0);
 698         test_color(hdcmem, PALETTERGB(pbmi->bmiColors[i].rgbRed, pbmi->bmiColors[i].rgbGreen, pbmi->bmiColors[i].rgbBlue),
 699             RGB(pbmi->bmiColors[i].rgbRed, pbmi->bmiColors[i].rgbGreen, pbmi->bmiColors[i].rgbBlue), 0, 0);
 700     }
 701
 702     SelectObject(hdcmem, oldbm);
 703     test_dib_info(hdib, bits, &pbmi->bmiHeader);
 704     DeleteObject(hdib);
 705
 706     pbmi->bmiHeader.biBitCount = 1;
 707
 708     /* Now create a palette and a palette indexed dib section */
 709     memset(plogpal, 0, sizeof(logpalbuf));
 710     plogpal->palVersion = 0x300;
 711     plogpal->palNumEntries = 2;
 712     plogpal->palPalEntry[0].peRed = 0xff;
 713     plogpal->palPalEntry[0].peBlue = 0xff;
 714     plogpal->palPalEntry[1].peGreen = 0xff;
 715
 716     index = (WORD*)pbmi->bmiColors;
 717     *index++ = 0;
 718     *index = 1;
 719     hpal = CreatePalette(plogpal);
 720     ok(hpal != NULL, "CreatePalette failed\n");
 721     oldpal = SelectPalette(hdc, hpal, TRUE);
 722     hdib = CreateDIBSection(hdc, pbmi, DIB_PAL_COLORS, (void**)&bits, NULL, 0);
 723     ok(hdib != NULL, "CreateDIBSection failed\n");
 724     ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
 725     ok(dibsec.dsBmih.biClrUsed == 2, "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 2);
 726
 727     /* The colour table has already been grabbed from the dc, so we select back the
 728        old palette */
 729
 730     SelectPalette(hdc, oldpal, TRUE);
 731     oldbm = SelectObject(hdcmem, hdib);
 732     oldpal = SelectPalette(hdcmem, hpal, TRUE);
 733
 734     ret = GetDIBColorTable(hdcmem, 0, 2, rgb);
 735     ok(ret == 2, "GetDIBColorTable returned %d\n", ret);
 736     ok(rgb[0].rgbRed == 0xff && rgb[0].rgbBlue == 0xff && rgb[0].rgbGreen == 0 &&
 737        rgb[1].rgbRed == 0    && rgb[1].rgbBlue == 0    && rgb[1].rgbGreen == 0xff,
 738        "GetDIBColorTable returns table 0: r%02x g%02x b%02x res%02x 1: r%02x g%02x b%02x res%02x\n",
 739        rgb[0].rgbRed, rgb[0].rgbGreen, rgb[0].rgbBlue, rgb[0].rgbReserved,
 740        rgb[1].rgbRed, rgb[1].rgbGreen, rgb[1].rgbBlue, rgb[1].rgbReserved);
 741
 742     c0 = RGB(plogpal->palPalEntry[0].peRed, plogpal->palPalEntry[0].peGreen, plogpal->palPalEntry[0].peBlue);
 743     c1 = RGB(plogpal->palPalEntry[1].peRed, plogpal->palPalEntry[1].peGreen, plogpal->palPalEntry[1].peBlue);
 744
 745     test_color(hdcmem, DIBINDEX(0), c0, 0, 1);
 746     test_color(hdcmem, DIBINDEX(1), c1, 0, 1);
 747     test_color(hdcmem, DIBINDEX(2), c0, 1, 1);
 748     test_color(hdcmem, PALETTEINDEX(0), c0, 0, 1);
 749     test_color(hdcmem, PALETTEINDEX(1), c1, 0, 1);
 750     test_color(hdcmem, PALETTEINDEX(2), c0, 1, 1);
 751     test_color(hdcmem, PALETTERGB(plogpal->palPalEntry[0].peRed, plogpal->palPalEntry[0].peGreen,
 752         plogpal->palPalEntry[0].peBlue), c0, 1, 1);
 753     test_color(hdcmem, PALETTERGB(plogpal->palPalEntry[1].peRed, plogpal->palPalEntry[1].peGreen,
 754         plogpal->palPalEntry[1].peBlue), c1, 1, 1);
 755     test_color(hdcmem, PALETTERGB(0, 0, 0), c1, 1, 1);
 756     test_color(hdcmem, PALETTERGB(0xff, 0xff, 0xff), c0, 1, 1);
 757     test_color(hdcmem, PALETTERGB(0, 0, 0xfe), c0, 1, 1);
 758     test_color(hdcmem, PALETTERGB(0, 1, 0), c1, 1, 1);
 759     test_color(hdcmem, PALETTERGB(0x3f, 0, 0x3f), c1, 1, 1);
 760     test_color(hdcmem, PALETTERGB(0x40, 0, 0x40), c0, 1, 1);
 761
 762     /* Bottom and 2nd row from top green, everything else magenta */
 763     bits[0] = bits[1] = 0xff;
 764     bits[13 * 4] = bits[13*4 + 1] = 0xff;
 765
 766     test_dib_info(hdib, bits, &pbmi->bmiHeader);
 767
 768     pbmi->bmiHeader.biBitCount = 32;
 769
 770     hdib2 = CreateDIBSection(NULL, pbmi, DIB_RGB_COLORS, (void **)&bits32, NULL, 0);
 771     ok(hdib2 != NULL, "CreateDIBSection failed\n");
 772     hdcmem2 = CreateCompatibleDC(hdc);
 773     oldbm2 = SelectObject(hdcmem2, hdib2);
 774
 775     BitBlt(hdcmem2, 0, 0, 16,16, hdcmem, 0, 0, SRCCOPY);
 776
 777     ok(bits32[0] == 0xff00, "lower left pixel is %08x\n", bits32[0]);
 778     ok(bits32[17] == 0xff00ff, "bottom but one, left pixel is %08x\n", bits32[17]);
 779
 780     SelectObject(hdcmem2, oldbm2);
 781     test_dib_info(hdib2, bits32, &pbmi->bmiHeader);
 782     DeleteObject(hdib2);
 783
 784     SelectObject(hdcmem, oldbm);
 785     SelectPalette(hdcmem, oldpal, TRUE);
 786     DeleteObject(hdib);
 787     DeleteObject(hpal);
 788
 789
 790     pbmi->bmiHeader.biBitCount = 8;
 791
 792     memset(plogpal, 0, sizeof(logpalbuf));
 793     plogpal->palVersion = 0x300;
 794     plogpal->palNumEntries = 256;
 795
 796     for (i = 0; i < 128; i++) {
 797         plogpal->palPalEntry[i].peRed = 255 - i * 2;
 798         plogpal->palPalEntry[i].peBlue = i * 2;
 799         plogpal->palPalEntry[i].peGreen = 0;
 800         plogpal->palPalEntry[255 - i].peRed = 0;
 801         plogpal->palPalEntry[255 - i].peGreen = i * 2;
 802         plogpal->palPalEntry[255 - i].peBlue = 255 - i * 2;
 803     }
 804
 805     index = (WORD*)pbmi->bmiColors;
 806     for (i = 0; i < 256; i++) {
 807         *index++ = i;
 808     }
 809
 810     hpal = CreatePalette(plogpal);
 811     ok(hpal != NULL, "CreatePalette failed\n");
 812     oldpal = SelectPalette(hdc, hpal, TRUE);
 813     hdib = CreateDIBSection(hdc, pbmi, DIB_PAL_COLORS, (void**)&bits, NULL, 0);
 814     ok(hdib != NULL, "CreateDIBSection failed\n");
 815     ok(GetObject(hdib, sizeof(DIBSECTION), &dibsec) != 0, "GetObject failed for DIB Section\n");
 816     ok(dibsec.dsBmih.biClrUsed == 256, "created DIBSection: wrong biClrUsed field: %u, should be: %u\n", dibsec.dsBmih.biClrUsed, 256);
 817
 818     test_dib_info(hdib, bits, &pbmi->bmiHeader);
 819
 820     SelectPalette(hdc, oldpal, TRUE);
 821     oldbm = SelectObject(hdcmem, hdib);
 822     oldpal = SelectPalette(hdcmem, hpal, TRUE);
 823
 824     ret = GetDIBColorTable(hdcmem, 0, 256, rgb);
 825     ok(ret == 256, "GetDIBColorTable returned %d\n", ret);
 826     for (i = 0; i < 256; i++) {
 827         ok(rgb[i].rgbRed == plogpal->palPalEntry[i].peRed &&
 828             rgb[i].rgbBlue == plogpal->palPalEntry[i].peBlue &&
 829             rgb[i].rgbGreen == plogpal->palPalEntry[i].peGreen,
 830             "GetDIBColorTable returns table %d: r%02x g%02x b%02x res%02x\n",
 831             i, rgb[i].rgbRed, rgb[i].rgbGreen, rgb[i].rgbBlue, rgb[i].rgbReserved);
 832     }
 833
 834     for (i = 0; i < 256; i++) {
 835         test_color(hdcmem, DIBINDEX(i),
 836             RGB(plogpal->palPalEntry[i].peRed, plogpal->palPalEntry[i].peGreen, plogpal->palPalEntry[i].peBlue), 0, 0);
 837         test_color(hdcmem, PALETTEINDEX(i),
 838             RGB(plogpal->palPalEntry[i].peRed, plogpal->palPalEntry[i].peGreen, plogpal->palPalEntry[i].peBlue), 0, 0);
 839         test_color(hdcmem, PALETTERGB(plogpal->palPalEntry[i].peRed, plogpal->palPalEntry[i].peGreen, plogpal->palPalEntry[i].peBlue),
 840             RGB(plogpal->palPalEntry[i].peRed, plogpal->palPalEntry[i].peGreen, plogpal->palPalEntry[i].peBlue), 0, 0);
 841     }
 842
 843     SelectPalette(hdcmem, oldpal, TRUE);
 844     SelectObject(hdcmem, oldbm);
 845     DeleteObject(hdib);
 846     DeleteObject(hpal);
 847
 848     DeleteDC(hdcmem);
 849     DeleteDC(hdcmem2);
 850     ReleaseDC(0, hdc);
 851 }
 852
 853 static void test_dib_formats(void)
 854 {
 855     char buffer[FIELD_OFFSET( BITMAPINFO, bmiColors[256])];
 856     BITMAPINFO *bi = (BITMAPINFO *)buffer;
 857     char data[256];
 858     void *bits;
 859     int planes, bpp, compr;
 860     HBITMAP hdib, hbmp;
 861     HDC hdc, memdc;
 862     UINT ret;
 863     BOOL expect_ok, todo;
 864
 865     hdc = GetDC( 0 );
 866     memdc = CreateCompatibleDC( 0 );
 867     hbmp = CreateCompatibleBitmap( hdc, 10, 10 );
 868
 869     memset( data, 0xaa, sizeof(data) );
 870
 871     for (bpp = 0; bpp <= 64; bpp++)
 872     {
 873         for (planes = 0; planes <= 64; planes++)
 874         {
 875             for (compr = 0; compr < 8; compr++)
 876             {
 877                 switch (bpp)
 878                 {
 879                 case 1:
 880                 case 4:
 881                 case 8:
 882                 case 24: expect_ok = (compr == BI_RGB); break;
 883                 case 16:
 884                 case 32: expect_ok = (compr == BI_RGB || compr == BI_BITFIELDS); break;
 885                 default: expect_ok = FALSE; break;
 886                 }
 887                 if (!planes) expect_ok = FALSE;
 888                 todo = (compr == BI_BITFIELDS);  /* wine doesn't like strange bitfields */
 889
 890                 memset( bi, 0, sizeof(bi->bmiHeader) );
 891                 bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 892                 bi->bmiHeader.biWidth = 2;
 893                 bi->bmiHeader.biHeight = 2;
 894                 bi->bmiHeader.biPlanes = planes;
 895                 bi->bmiHeader.biBitCount = bpp;
 896                 bi->bmiHeader.biCompression = compr;
 897                 bi->bmiHeader.biSizeImage = 0;
 898                 memset( bi->bmiColors, 0xaa, sizeof(RGBQUAD) * 256 );
 899
 900                 hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
 901                 if (expect_ok && (planes == 1 || planes * bpp <= 16))
 902                     ok( hdib != NULL, "CreateDIBSection failed for %u/%u/%u\n", bpp, planes, compr );
 903                 else
 904                     ok( hdib == NULL, "CreateDIBSection succeeded for %u/%u/%u\n", bpp, planes, compr );
 905                 if (hdib) DeleteObject( hdib );
 906
 907                 hdib = CreateDIBitmap( hdc, &bi->bmiHeader, 0, data, bi, DIB_RGB_COLORS );
 908                 /* no sanity checks in CreateDIBitmap except compression */
 909                 if (compr == BI_JPEG || compr == BI_PNG)
 910                     ok( hdib == NULL || broken(hdib != NULL), /* nt4 */
 911                         "CreateDIBitmap succeeded for %u/%u/%u\n", bpp, planes, compr );
 912                 else
 913                     ok( hdib != NULL, "CreateDIBitmap failed for %u/%u/%u\n", bpp, planes, compr );
 914                 if (hdib) DeleteObject( hdib );
 915
 916                 /* RLE needs a size */
 917                 bi->bmiHeader.biSizeImage = 0;
 918                 ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, DIB_RGB_COLORS);
 919                 if (expect_ok)
 920                 {
 921                     if (todo)
 922                         todo_wine ok( ret, "SetDIBits failed for %u/%u/%u\n", bpp, planes, compr );
 923                     else
 924                         ok( ret, "SetDIBits failed for %u/%u/%u\n", bpp, planes, compr );
 925                 }
 926                 else
 927                     ok( !ret ||
 928                         broken((bpp == 4 && compr == BI_RLE4) || (bpp == 8 && compr == BI_RLE8)), /* nt4 */
 929                         "SetDIBits succeeded for %u/%u/%u\n", bpp, planes, compr );
 930                 ret = SetDIBitsToDevice( memdc, 0, 0, 1, 1, 0, 0, 0, 1, data, bi, DIB_RGB_COLORS );
 931                 if (expect_ok)
 932                     ok( ret, "SetDIBitsToDevice failed for %u/%u/%u\n", bpp, planes, compr );
 933                 else
 934                     ok( !ret ||
 935                         broken((bpp == 4 && compr == BI_RLE4) || (bpp == 8 && compr == BI_RLE8)), /* nt4 */
 936                         "SetDIBitsToDevice succeeded for %u/%u/%u\n", bpp, planes, compr );
 937                 ret = StretchDIBits( memdc, 0, 0, 1, 1, 0, 0, 1, 1, data, bi, DIB_RGB_COLORS, SRCCOPY );
 938                 if (expect_ok)
 939                 {
 940                     if (todo)
 941                         todo_wine ok( ret, "StretchDIBits failed for %u/%u/%u\n", bpp, planes, compr );
 942                     else
 943                         ok( ret, "StretchDIBits failed for %u/%u/%u\n", bpp, planes, compr );
 944                 }
 945                 else
 946                     ok( !ret ||
 947                         broken((bpp == 4 && compr == BI_RLE4) || (bpp == 8 && compr == BI_RLE8)), /* nt4 */
 948                         "StretchDIBits succeeded for %u/%u/%u\n", bpp, planes, compr );
 949
 950                 bi->bmiHeader.biSizeImage = 1;
 951                 ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, DIB_RGB_COLORS);
 952                 if (expect_ok || (bpp == 4 && compr == BI_RLE4) || (bpp == 8 && compr == BI_RLE8))
 953                 {
 954                     if (todo)
 955                         todo_wine ok( ret, "SetDIBits failed for %u/%u/%u\n", bpp, planes, compr );
 956                     else
 957                         ok( ret, "SetDIBits failed for %u/%u/%u\n", bpp, planes, compr );
 958                 }
 959                 else
 960                     ok( !ret, "SetDIBits succeeded for %u/%u/%u\n", bpp, planes, compr );
 961                 ret = SetDIBitsToDevice( memdc, 0, 0, 1, 1, 0, 0, 0, 1, data, bi, DIB_RGB_COLORS );
 962                 if (expect_ok || (bpp == 4 && compr == BI_RLE4) || (bpp == 8 && compr == BI_RLE8))
 963                     ok( ret, "SetDIBitsToDevice failed for %u/%u/%u\n", bpp, planes, compr );
 964                 else
 965                     ok( !ret, "SetDIBitsToDevice succeeded for %u/%u/%u\n", bpp, planes, compr );
 966                 ret = StretchDIBits( memdc, 0, 0, 1, 1, 0, 0, 1, 1, data, bi, DIB_RGB_COLORS, SRCCOPY );
 967                 if (expect_ok || (bpp == 4 && compr == BI_RLE4) || (bpp == 8 && compr == BI_RLE8))
 968                 {
 969                     if (todo)
 970                         todo_wine ok( ret, "StretchDIBits failed for %u/%u/%u\n", bpp, planes, compr );
 971                     else
 972                         ok( ret, "StretchDIBits failed for %u/%u/%u\n", bpp, planes, compr );
 973                 }
 974                 else
 975                     ok( !ret, "StretchDIBits succeeded for %u/%u/%u\n", bpp, planes, compr );
 976             }
 977         }
 978     }
 979
 980     memset( bi, 0, sizeof(bi->bmiHeader) );
 981     bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 982     bi->bmiHeader.biWidth = 2;
 983     bi->bmiHeader.biHeight = 2;
 984     bi->bmiHeader.biPlanes = 1;
 985     bi->bmiHeader.biBitCount = 16;
 986     bi->bmiHeader.biCompression = BI_BITFIELDS;
 987     bi->bmiHeader.biSizeImage = 0;
 988     *(DWORD *)&bi->bmiColors[0] = 0;
 989     *(DWORD *)&bi->bmiColors[1] = 0;
 990     *(DWORD *)&bi->bmiColors[2] = 0;
 991
 992     hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
 993     ok( hdib == NULL, "CreateDIBSection succeeded with null bitfields\n" );
 994     ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, DIB_RGB_COLORS);
 995     ok( !ret, "SetDIBits succeeded with null bitfields\n" );
 996     /* other functions don't check */
 997     hdib = CreateDIBitmap( hdc, &bi->bmiHeader, 0, bits, bi, DIB_RGB_COLORS );
 998     ok( hdib != NULL, "CreateDIBitmap failed with null bitfields\n" );
 999     DeleteObject( hdib );
1000     ret = SetDIBitsToDevice( memdc, 0, 0, 1, 1, 0, 0, 0, 1, data, bi, DIB_RGB_COLORS );
1001     ok( ret, "SetDIBitsToDevice failed with null bitfields\n" );
1002     ret = StretchDIBits( memdc, 0, 0, 1, 1, 0, 0, 1, 1, data, bi, DIB_RGB_COLORS, SRCCOPY );
1003     todo_wine ok( ret, "StretchDIBits failed with null bitfields\n" );
1004
1005     /* all fields must be non-zero */
1006     *(DWORD *)&bi->bmiColors[0] = 3;
1007     *(DWORD *)&bi->bmiColors[1] = 0;
1008     *(DWORD *)&bi->bmiColors[2] = 7;
1009     hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1010     ok( hdib == NULL, "CreateDIBSection succeeded with null bitfields\n" );
1011     ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, DIB_RGB_COLORS);
1012     ok( !ret, "SetDIBits succeeded with null bitfields\n" );
1013
1014     /* garbage is ok though */
1015     *(DWORD *)&bi->bmiColors[0] = 0x55;
1016     *(DWORD *)&bi->bmiColors[1] = 0x44;
1017     *(DWORD *)&bi->bmiColors[2] = 0x33;
1018     hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1019     ok( hdib != NULL, "CreateDIBSection failed with bad bitfields\n" );
1020     if (hdib) DeleteObject( hdib );
1021     ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, DIB_RGB_COLORS);
1022     todo_wine ok( ret, "SetDIBits failed with bad bitfields\n" );
1023
1024     bi->bmiHeader.biWidth = -2;
1025     bi->bmiHeader.biHeight = 2;
1026     bi->bmiHeader.biBitCount = 32;
1027     bi->bmiHeader.biCompression = BI_RGB;
1028     hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1029     ok( hdib == NULL, "CreateDIBSection succeeded with negative width\n" );
1030     hdib = CreateDIBitmap( hdc, &bi->bmiHeader, 0, bits, bi, DIB_RGB_COLORS );
1031     ok( hdib == NULL, "CreateDIBitmap succeeded with negative width\n" );
1032     ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, DIB_RGB_COLORS);
1033     ok( !ret, "SetDIBits succeeded with negative width\n" );
1034     ret = SetDIBitsToDevice( memdc, 0, 0, 1, 1, 0, 0, 0, 1, data, bi, DIB_RGB_COLORS );
1035     ok( !ret, "SetDIBitsToDevice succeeded with negative width\n" );
1036     ret = StretchDIBits( memdc, 0, 0, 1, 1, 0, 0, 1, 1, data, bi, DIB_RGB_COLORS, SRCCOPY );
1037     ok( !ret, "StretchDIBits succeeded with negative width\n" );
1038
1039     bi->bmiHeader.biWidth = 0;
1040     bi->bmiHeader.biHeight = 2;
1041     bi->bmiHeader.biBitCount = 32;
1042     bi->bmiHeader.biCompression = BI_RGB;
1043     hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1044     ok( hdib == NULL, "CreateDIBSection succeeded with zero width\n" );
1045     hdib = CreateDIBitmap( hdc, &bi->bmiHeader, 0, bits, bi, DIB_RGB_COLORS );
1046     ok( hdib != NULL, "CreateDIBitmap failed with zero width\n" );
1047     DeleteObject( hdib );
1048     ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, DIB_RGB_COLORS);
1049     ok( !ret || broken(ret), /* nt4 */ "SetDIBits succeeded with zero width\n" );
1050     ret = SetDIBitsToDevice( memdc, 0, 0, 1, 1, 0, 0, 0, 1, data, bi, DIB_RGB_COLORS );
1051     ok( !ret || broken(ret), /* nt4 */ "SetDIBitsToDevice succeeded with zero width\n" );
1052     ret = StretchDIBits( memdc, 0, 0, 1, 1, 0, 0, 1, 1, data, bi, DIB_RGB_COLORS, SRCCOPY );
1053     ok( !ret || broken(ret), /* nt4 */ "StretchDIBits succeeded with zero width\n" );
1054
1055     bi->bmiHeader.biWidth = 2;
1056     bi->bmiHeader.biHeight = 0;
1057     bi->bmiHeader.biBitCount = 32;
1058     bi->bmiHeader.biCompression = BI_RGB;
1059     hdib = CreateDIBSection(hdc, bi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1060     ok( hdib == NULL, "CreateDIBSection succeeded with zero height\n" );
1061     hdib = CreateDIBitmap( hdc, &bi->bmiHeader, 0, bits, bi, DIB_RGB_COLORS );
1062     ok( hdib != NULL, "CreateDIBitmap failed with zero height\n" );
1063     DeleteObject( hdib );
1064     ret = SetDIBits(hdc, hbmp, 0, 1, data, bi, DIB_RGB_COLORS);
1065     ok( !ret, "SetDIBits succeeded with zero height\n" );
1066     ret = SetDIBitsToDevice( memdc, 0, 0, 1, 1, 0, 0, 0, 1, data, bi, DIB_RGB_COLORS );
1067     ok( !ret, "SetDIBitsToDevice succeeded with zero height\n" );
1068     ret = StretchDIBits( memdc, 0, 0, 1, 1, 0, 0, 1, 1, data, bi, DIB_RGB_COLORS, SRCCOPY );
1069     ok( !ret, "StretchDIBits succeeded with zero height\n" );
1070
1071     DeleteDC( memdc );
1072     DeleteObject( hbmp );
1073     ReleaseDC( 0, hdc );
1074 }
1075
1076 static void test_mono_dibsection(void)
1077 {
1078     HDC hdc, memdc;
1079     HBITMAP old_bm, mono_ds;
1080     char bmibuf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)];
1081     BITMAPINFO *pbmi = (BITMAPINFO *)bmibuf;
1082     BYTE bits[10 * 4];
1083     BYTE *ds_bits;
1084     int num;
1085
1086     hdc = GetDC(0);
1087
1088     memdc = CreateCompatibleDC(hdc);
1089
1090     memset(pbmi, 0, sizeof(bmibuf));
1091     pbmi->bmiHeader.biSize = sizeof(pbmi->bmiHeader);
1092     pbmi->bmiHeader.biHeight = 10;
1093     pbmi->bmiHeader.biWidth = 10;
1094     pbmi->bmiHeader.biBitCount = 1;
1095     pbmi->bmiHeader.biPlanes = 1;
1096     pbmi->bmiHeader.biCompression = BI_RGB;
1097     pbmi->bmiColors[0].rgbRed = 0xff;
1098     pbmi->bmiColors[0].rgbGreen = 0xff;
1099     pbmi->bmiColors[0].rgbBlue = 0xff;
1100     pbmi->bmiColors[1].rgbRed = 0x0;
1101     pbmi->bmiColors[1].rgbGreen = 0x0;
1102     pbmi->bmiColors[1].rgbBlue = 0x0;
1103
1104     /*
1105      * First dib section is 'inverted' ie color[0] is white, color[1] is black
1106      */
1107
1108     mono_ds = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&ds_bits, NULL, 0);
1109     ok(mono_ds != NULL, "CreateDIBSection rets NULL\n");
1110     old_bm = SelectObject(memdc, mono_ds);
1111
1112     /* black border, white interior */
1113     Rectangle(memdc, 0, 0, 10, 10);
1114     ok(ds_bits[0] == 0xff, "out_bits %02x\n", ds_bits[0]);
1115     ok(ds_bits[4] == 0x80, "out_bits %02x\n", ds_bits[4]);
1116
1117     /* SetDIBitsToDevice with an inverted bmi -> inverted dib section */
1118
1119     memset(bits, 0, sizeof(bits));
1120     bits[0] = 0xaa;
1121
1122     SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
1123     ok(ds_bits[0] == 0xaa, "out_bits %02x\n", ds_bits[0]);
1124
1125     /* SetDIBitsToDevice with a normal bmi -> inverted dib section */
1126
1127     pbmi->bmiColors[0].rgbRed = 0x0;
1128     pbmi->bmiColors[0].rgbGreen = 0x0;
1129     pbmi->bmiColors[0].rgbBlue = 0x0;
1130     pbmi->bmiColors[1].rgbRed = 0xff;
1131     pbmi->bmiColors[1].rgbGreen = 0xff;
1132     pbmi->bmiColors[1].rgbBlue = 0xff;
1133
1134     SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
1135     ok(ds_bits[0] == 0x55, "out_bits %02x\n", ds_bits[0]);
1136
1137     SelectObject(memdc, old_bm);
1138     DeleteObject(mono_ds);
1139
1140     /*
1141      * Next dib section is 'normal' ie color[0] is black, color[1] is white
1142      */
1143
1144     pbmi->bmiColors[0].rgbRed = 0x0;
1145     pbmi->bmiColors[0].rgbGreen = 0x0;
1146     pbmi->bmiColors[0].rgbBlue = 0x0;
1147     pbmi->bmiColors[1].rgbRed = 0xff;
1148     pbmi->bmiColors[1].rgbGreen = 0xff;
1149     pbmi->bmiColors[1].rgbBlue = 0xff;
1150
1151     mono_ds = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&ds_bits, NULL, 0);
1152     ok(mono_ds != NULL, "CreateDIBSection rets NULL\n");
1153     old_bm = SelectObject(memdc, mono_ds);
1154
1155     /* black border, white interior */
1156     Rectangle(memdc, 0, 0, 10, 10);
1157     ok(ds_bits[0] == 0x00, "out_bits %02x\n", ds_bits[0]);
1158     ok(ds_bits[4] == 0x7f, "out_bits %02x\n", ds_bits[4]);
1159
1160     /* SetDIBitsToDevice with a normal bmi -> normal dib section */
1161
1162     SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
1163     ok(ds_bits[0] == 0xaa, "out_bits %02x\n", ds_bits[0]);
1164
1165     /* SetDIBitsToDevice with a inverted bmi -> normal dib section */
1166
1167     pbmi->bmiColors[0].rgbRed = 0xff;
1168     pbmi->bmiColors[0].rgbGreen = 0xff;
1169     pbmi->bmiColors[0].rgbBlue = 0xff;
1170     pbmi->bmiColors[1].rgbRed = 0x0;
1171     pbmi->bmiColors[1].rgbGreen = 0x0;
1172     pbmi->bmiColors[1].rgbBlue = 0x0;
1173
1174     SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
1175     ok(ds_bits[0] == 0x55, "out_bits %02x\n", ds_bits[0]);
1176
1177     /*
1178      * Take that 'normal' dibsection and change its colour table to an 'inverted' one
1179      */
1180
1181     pbmi->bmiColors[0].rgbRed = 0xff;
1182     pbmi->bmiColors[0].rgbGreen = 0xff;
1183     pbmi->bmiColors[0].rgbBlue = 0xff;
1184     pbmi->bmiColors[1].rgbRed = 0x0;
1185     pbmi->bmiColors[1].rgbGreen = 0x0;
1186     pbmi->bmiColors[1].rgbBlue = 0x0;
1187     num = SetDIBColorTable(memdc, 0, 2, pbmi->bmiColors);
1188     ok(num == 2, "num = %d\n", num);
1189
1190     /* black border, white interior */
1191     Rectangle(memdc, 0, 0, 10, 10);
1192     ok(ds_bits[0] == 0xff, "out_bits %02x\n", ds_bits[0]);
1193     ok(ds_bits[4] == 0x80, "out_bits %02x\n", ds_bits[4]);
1194
1195     /* SetDIBitsToDevice with an inverted bmi -> inverted dib section */
1196
1197     memset(bits, 0, sizeof(bits));
1198     bits[0] = 0xaa;
1199
1200     SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
1201     ok(ds_bits[0] == 0xaa, "out_bits %02x\n", ds_bits[0]);
1202
1203     /* SetDIBitsToDevice with a normal bmi -> inverted dib section */
1204
1205     pbmi->bmiColors[0].rgbRed = 0x0;
1206     pbmi->bmiColors[0].rgbGreen = 0x0;
1207     pbmi->bmiColors[0].rgbBlue = 0x0;
1208     pbmi->bmiColors[1].rgbRed = 0xff;
1209     pbmi->bmiColors[1].rgbGreen = 0xff;
1210     pbmi->bmiColors[1].rgbBlue = 0xff;
1211
1212     SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
1213     ok(ds_bits[0] == 0x55, "out_bits %02x\n", ds_bits[0]);
1214
1215     SelectObject(memdc, old_bm);
1216     DeleteObject(mono_ds);
1217
1218     /*
1219      * Now a dib section with a strange colour map just for fun.  This behaves just like an inverted one.
1220      */
1221
1222     pbmi->bmiColors[0].rgbRed = 0xff;
1223     pbmi->bmiColors[0].rgbGreen = 0x0;
1224     pbmi->bmiColors[0].rgbBlue = 0x0;
1225     pbmi->bmiColors[1].rgbRed = 0xfe;
1226     pbmi->bmiColors[1].rgbGreen = 0x0;
1227     pbmi->bmiColors[1].rgbBlue = 0x0;
1228
1229     mono_ds = CreateDIBSection(hdc, pbmi, DIB_RGB_COLORS, (void**)&ds_bits, NULL, 0);
1230     ok(mono_ds != NULL, "CreateDIBSection rets NULL\n");
1231     old_bm = SelectObject(memdc, mono_ds);
1232
1233     /* black border, white interior */
1234     Rectangle(memdc, 0, 0, 10, 10);
1235     ok(ds_bits[0] == 0xff, "out_bits %02x\n", ds_bits[0]);
1236     ok(ds_bits[4] == 0x80, "out_bits %02x\n", ds_bits[4]);
1237
1238     /* SetDIBitsToDevice with a normal bmi -> inverted dib section */
1239
1240     pbmi->bmiColors[0].rgbRed = 0x0;
1241     pbmi->bmiColors[0].rgbGreen = 0x0;
1242     pbmi->bmiColors[0].rgbBlue = 0x0;
1243     pbmi->bmiColors[1].rgbRed = 0xff;
1244     pbmi->bmiColors[1].rgbGreen = 0xff;
1245     pbmi->bmiColors[1].rgbBlue = 0xff;
1246
1247     SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
1248     ok(ds_bits[0] == 0x55, "out_bits %02x\n", ds_bits[0]);
1249
1250     /* SetDIBitsToDevice with a inverted bmi -> inverted dib section */
1251
1252     pbmi->bmiColors[0].rgbRed = 0xff;
1253     pbmi->bmiColors[0].rgbGreen = 0xff;
1254     pbmi->bmiColors[0].rgbBlue = 0xff;
1255     pbmi->bmiColors[1].rgbRed = 0x0;
1256     pbmi->bmiColors[1].rgbGreen = 0x0;
1257     pbmi->bmiColors[1].rgbBlue = 0x0;
1258
1259     SetDIBitsToDevice(memdc, 0, 0, 10, 10, 0, 0, 0, 10, bits, pbmi, DIB_RGB_COLORS);
1260     ok(ds_bits[0] == 0xaa, "out_bits %02x\n", ds_bits[0]);
1261
1262     SelectObject(memdc, old_bm);
1263     DeleteObject(mono_ds);
1264
1265     DeleteDC(memdc);
1266     ReleaseDC(0, hdc);
1267 }
1268
1269 static void test_bitmap(void)
1270 {
1271     char buf[256], buf_cmp[256];
1272     HBITMAP hbmp, hbmp_old;
1273     HDC hdc;
1274     BITMAP bm;
1275     BITMAP bma[2];
1276     INT ret;
1277
1278     hdc = CreateCompatibleDC(0);
1279     assert(hdc != 0);
1280
1281     SetLastError(0xdeadbeef);
1282     hbmp = CreateBitmap(0x7ffffff, 1, 1, 1, NULL);
1283     if (!hbmp)
1284     {
1285         ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY /* XP */ ||
1286            GetLastError() == ERROR_INVALID_PARAMETER /* Win2k */,
1287            "expected ERROR_NOT_ENOUGH_MEMORY, got %u\n", GetLastError());
1288     }
1289     else
1290         DeleteObject(hbmp);
1291
1292     SetLastError(0xdeadbeef);
1293     hbmp = CreateBitmap(0x7ffffff, 9, 1, 1, NULL);
1294     if (!hbmp)
1295     {
1296         ok(GetLastError() == ERROR_NOT_ENOUGH_MEMORY /* XP */ ||
1297            GetLastError() == ERROR_INVALID_PARAMETER /* Win2k */,
1298            "expected ERROR_NOT_ENOUGH_MEMORY, got %u\n", GetLastError());
1299     }
1300     else
1301         DeleteObject(hbmp);
1302
1303     SetLastError(0xdeadbeef);
1304     hbmp = CreateBitmap(0x7ffffff + 1, 1, 1, 1, NULL);
1305     ok(!hbmp, "CreateBitmap should fail\n");
1306     if (!hbmp)
1307         ok(GetLastError() == ERROR_INVALID_PARAMETER,
1308            "expected ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
1309     else
1310         DeleteObject(hbmp);
1311
1312     hbmp = CreateBitmap(15, 15, 1, 1, NULL);
1313     assert(hbmp != NULL);
1314
1315     ret = GetObject(hbmp, sizeof(bm), &bm);
1316     ok(ret == sizeof(bm), "wrong size %d\n", ret);
1317
1318     ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
1319     ok(bm.bmWidth == 15, "wrong bm.bmWidth %d\n", bm.bmWidth);
1320     ok(bm.bmHeight == 15, "wrong bm.bmHeight %d\n", bm.bmHeight);
1321     ok(bm.bmWidthBytes == 2, "wrong bm.bmWidthBytes %d\n", bm.bmWidthBytes);
1322     ok(bm.bmPlanes == 1, "wrong bm.bmPlanes %d\n", bm.bmPlanes);
1323     ok(bm.bmBitsPixel == 1, "wrong bm.bmBitsPixel %d\n", bm.bmBitsPixel);
1324     ok(bm.bmBits == NULL, "wrong bm.bmBits %p\n", bm.bmBits);
1325
1326     assert(sizeof(buf) >= bm.bmWidthBytes * bm.bmHeight);
1327     assert(sizeof(buf) == sizeof(buf_cmp));
1328
1329     ret = GetBitmapBits(hbmp, 0, NULL);
1330     ok(ret == bm.bmWidthBytes * bm.bmHeight, "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
1331
1332     memset(buf_cmp, 0xAA, sizeof(buf_cmp));
1333     memset(buf_cmp, 0, bm.bmWidthBytes * bm.bmHeight);
1334
1335     memset(buf, 0xAA, sizeof(buf));
1336     ret = GetBitmapBits(hbmp, sizeof(buf), buf);
1337     ok(ret == bm.bmWidthBytes * bm.bmHeight, "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
1338     ok(!memcmp(buf, buf_cmp, sizeof(buf)), "buffers do not match\n");
1339
1340     hbmp_old = SelectObject(hdc, hbmp);
1341
1342     ret = GetObject(hbmp, sizeof(bm), &bm);
1343     ok(ret == sizeof(bm), "wrong size %d\n", ret);
1344
1345     ok(bm.bmType == 0, "wrong bm.bmType %d\n", bm.bmType);
1346     ok(bm.bmWidth == 15, "wrong bm.bmWidth %d\n", bm.bmWidth);
1347     ok(bm.bmHeight == 15, "wrong bm.bmHeight %d\n", bm.bmHeight);
1348     ok(bm.bmWidthBytes == 2, "wrong bm.bmWidthBytes %d\n", bm.bmWidthBytes);
1349     ok(bm.bmPlanes == 1, "wrong bm.bmPlanes %d\n", bm.bmPlanes);
1350     ok(bm.bmBitsPixel == 1, "wrong bm.bmBitsPixel %d\n", bm.bmBitsPixel);
1351     ok(bm.bmBits == NULL, "wrong bm.bmBits %p\n", bm.bmBits);
1352
1353     memset(buf, 0xAA, sizeof(buf));
1354     ret = GetBitmapBits(hbmp, sizeof(buf), buf);
1355     ok(ret == bm.bmWidthBytes * bm.bmHeight, "%d != %d\n", ret, bm.bmWidthBytes * bm.bmHeight);
1356     ok(!memcmp(buf, buf_cmp, sizeof(buf)), "buffers do not match\n");
1357
1358     hbmp_old = SelectObject(hdc, hbmp_old);
1359     ok(hbmp_old == hbmp, "wrong old bitmap %p\n", hbmp_old);
1360
1361     /* test various buffer sizes for GetObject */
1362     ret = GetObject(hbmp, sizeof(*bma) * 2, bma);
1363     ok(ret == sizeof(*bma), "wrong size %d\n", ret);
1364
1365     ret = GetObject(hbmp, sizeof(bm) / 2, &bm);
1366     ok(ret == 0, "%d != 0\n", ret);
1367
1368     ret = GetObject(hbmp, 0, &bm);
1369     ok(ret == 0, "%d != 0\n", ret);
1370
1371     ret = GetObject(hbmp, 1, &bm);
1372     ok(ret == 0, "%d != 0\n", ret);
1373
1374     DeleteObject(hbmp);
1375     DeleteDC(hdc);
1376 }
1377
1378 static void test_bmBits(void)
1379 {
1380     BYTE bits[4];
1381     HBITMAP hbmp;
1382     BITMAP bmp;
1383
1384     memset(bits, 0, sizeof(bits));
1385     hbmp = CreateBitmap(2, 2, 1, 4, bits);
1386     ok(hbmp != NULL, "CreateBitmap failed\n");
1387
1388     memset(&bmp, 0xFF, sizeof(bmp));
1389     ok(GetObject(hbmp, sizeof(bmp), &bmp) == sizeof(bmp),
1390        "GetObject failed or returned a wrong structure size\n");
1391     ok(!bmp.bmBits, "bmBits must be NULL for device-dependent bitmaps\n");
1392
1393     DeleteObject(hbmp);
1394 }
1395
1396 static void test_GetDIBits_selected_DIB(UINT bpp)
1397 {
1398     HBITMAP dib;
1399     char bmibuf[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
1400     char bmibuf2[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
1401     BITMAPINFO *info = (BITMAPINFO *)bmibuf;
1402     BITMAPINFO *info2 = (BITMAPINFO *)bmibuf2;
1403     void * bits;
1404     void * bits2;
1405     UINT dib_size, dib32_size;
1406     DWORD pixel;
1407     HDC dib_dc, dc;
1408     HBITMAP old_bmp;
1409     UINT i;
1410     int res;
1411
1412     /* Create a DIB section with a color table */
1413
1414     info->bmiHeader.biSize          = sizeof(info->bmiHeader);
1415     info->bmiHeader.biWidth         = 32;
1416     info->bmiHeader.biHeight        = 32;
1417     info->bmiHeader.biPlanes        = 1;
1418     info->bmiHeader.biBitCount      = bpp;
1419     info->bmiHeader.biCompression   = BI_RGB;
1420     info->bmiHeader.biXPelsPerMeter = 0;
1421     info->bmiHeader.biYPelsPerMeter = 0;
1422     info->bmiHeader.biClrUsed       = 0;
1423     info->bmiHeader.biClrImportant  = 0;
1424
1425     for (i=0; i < (1u << bpp); i++)
1426     {
1427         BYTE c = i * (1 << (8 - bpp));
1428         info->bmiColors[i].rgbRed = c;
1429         info->bmiColors[i].rgbGreen = c;
1430         info->bmiColors[i].rgbBlue = c;
1431         info->bmiColors[i].rgbReserved = 0;
1432     }
1433
1434     dib = CreateDIBSection(NULL, info, DIB_RGB_COLORS, &bits, NULL, 0);
1435     dib_size = bpp * (info->bmiHeader.biWidth * info->bmiHeader.biHeight) / 8;
1436     dib32_size = 32 * (info->bmiHeader.biWidth * info->bmiHeader.biHeight) / 8;
1437
1438     /* Set the bits of the DIB section */
1439     for (i=0; i < dib_size; i++)
1440     {
1441         ((BYTE *)bits)[i] = i % 256;
1442     }
1443
1444     /* Select the DIB into a DC */
1445     dib_dc = CreateCompatibleDC(NULL);
1446     old_bmp = SelectObject(dib_dc, dib);
1447     dc = CreateCompatibleDC(NULL);
1448     bits2 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, dib32_size);
1449
1450     /* Copy the DIB attributes but not the color table */
1451     memcpy(info2, info, sizeof(BITMAPINFOHEADER));
1452
1453     res = GetDIBits(dc, dib, 0, info->bmiHeader.biHeight, bits2, info2, DIB_RGB_COLORS);
1454     ok( res == info->bmiHeader.biHeight, "got %d (bpp %d)\n", res, bpp );
1455
1456     /* Compare the color table and the bits */
1457     for (i=0; i < (1u << bpp); i++)
1458         ok( info->bmiColors[i].rgbRed      == info2->bmiColors[i].rgbRed   &&
1459             info->bmiColors[i].rgbGreen    == info2->bmiColors[i].rgbGreen &&
1460             info->bmiColors[i].rgbBlue     == info2->bmiColors[i].rgbBlue  &&
1461             info->bmiColors[i].rgbReserved == info2->bmiColors[i].rgbReserved,
1462             "color table entry %d differs (bpp %d)\n", i, bpp );
1463
1464     ok( !memcmp( bits, bits2, dib_size ), "bit mismatch (bpp %d)\n", bpp );
1465
1466     /* Test various combinations of lines = 0 and bits2 = NULL */
1467     memset( info2->bmiColors, 0xcc, 256 * sizeof(RGBQUAD) );
1468     res = GetDIBits( dc, dib, 0, 0, bits2, info2, DIB_RGB_COLORS );
1469     ok( res == 1, "got %d (bpp %d)\n", res, bpp );
1470     ok( !memcmp( info->bmiColors, info2->bmiColors, (1 << bpp) * sizeof(RGBQUAD) ),
1471         "color table mismatch (bpp %d)\n", bpp );
1472
1473     memset( info2->bmiColors, 0xcc, 256 * sizeof(RGBQUAD) );
1474     res = GetDIBits( dc, dib, 0, 0, NULL, info2, DIB_RGB_COLORS );
1475     ok( res == 1, "got %d (bpp %d)\n", res, bpp );
1476     ok( !memcmp( info->bmiColors, info2->bmiColors, (1 << bpp) * sizeof(RGBQUAD) ),
1477         "color table mismatch (bpp %d)\n", bpp );
1478
1479     memset( info2->bmiColors, 0xcc, 256 * sizeof(RGBQUAD) );
1480     res = GetDIBits( dc, dib, 0, info->bmiHeader.biHeight, NULL, info2, DIB_RGB_COLORS );
1481     ok( res == 1, "got %d (bpp %d)\n", res, bpp );
1482     ok( !memcmp( info->bmiColors, info2->bmiColors, (1 << bpp) * sizeof(RGBQUAD) ),
1483         "color table mismatch (bpp %d)\n", bpp );
1484
1485     /* Map into a 32bit-DIB */
1486     info2->bmiHeader.biBitCount = 32;
1487     res = GetDIBits(dc, dib, 0, info->bmiHeader.biHeight, bits2, info2, DIB_RGB_COLORS);
1488     ok( res == info->bmiHeader.biHeight, "got %d (bpp %d)\n", res, bpp );
1489
1490     /* Check if last pixel was set */
1491     pixel = ((DWORD *)bits2)[info->bmiHeader.biWidth * info->bmiHeader.biHeight - 1];
1492     ok(pixel != 0, "Pixel: 0x%08x\n", pixel);
1493
1494     HeapFree(GetProcessHeap(), 0, bits2);
1495     DeleteDC(dc);
1496
1497     SelectObject(dib_dc, old_bmp);
1498     DeleteDC(dib_dc);
1499     DeleteObject(dib);
1500 }
1501
1502 static void test_GetDIBits_selected_DDB(BOOL monochrome)
1503 {
1504     HBITMAP ddb;
1505     char bmibuf[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
1506     char bmibuf2[FIELD_OFFSET( BITMAPINFO, bmiColors[256] )];
1507     BITMAPINFO *info = (BITMAPINFO *)bmibuf;
1508     BITMAPINFO *info2 = (BITMAPINFO *)bmibuf2;
1509     void * bits;
1510     void * bits2;
1511     HDC ddb_dc, dc;
1512     HBITMAP old_bmp;
1513     UINT width, height;
1514     UINT bpp;
1515     UINT i, j;
1516     int res;
1517
1518     width = height = 16;
1519
1520     /* Create a DDB (device-dependent bitmap) */
1521     if (monochrome)
1522     {
1523         bpp = 1;
1524         ddb = CreateBitmap(width, height, 1, 1, NULL);
1525     }
1526     else
1527     {
1528         HDC screen_dc = GetDC(NULL);
1529         bpp = GetDeviceCaps(screen_dc, BITSPIXEL) * GetDeviceCaps(screen_dc, PLANES);
1530         ddb = CreateCompatibleBitmap(screen_dc, width, height);
1531         ReleaseDC(NULL, screen_dc);
1532     }
1533
1534     /* Set the pixels */
1535     ddb_dc = CreateCompatibleDC(NULL);
1536     old_bmp = SelectObject(ddb_dc, ddb);
1537     for (i = 0; i < width; i++)
1538     {
1539         for (j=0; j < height; j++)
1540         {
1541             BYTE c = (i * width + j) % 256;
1542             SetPixelV(ddb_dc, i, j, RGB(c, c, c));
1543         }
1544     }
1545     SelectObject(ddb_dc, old_bmp);
1546
1547     info->bmiHeader.biSize = sizeof(info->bmiHeader);
1548     info->bmiHeader.biWidth = width;
1549     info->bmiHeader.biHeight = height;
1550     info->bmiHeader.biPlanes = 1;
1551     info->bmiHeader.biBitCount = bpp;
1552     info->bmiHeader.biCompression = BI_RGB;
1553
1554     dc = CreateCompatibleDC(NULL);
1555
1556     /* Fill in biSizeImage */
1557     GetDIBits(dc, ddb, 0, height, NULL, info, DIB_RGB_COLORS);
1558     ok(info->bmiHeader.biSizeImage != 0, "GetDIBits failed to get the DIB attributes\n");
1559
1560     bits = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, info->bmiHeader.biSizeImage);
1561     bits2 = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, info->bmiHeader.biSizeImage);
1562
1563     /* Get the bits */
1564     res = GetDIBits(dc, ddb, 0, height, bits, info, DIB_RGB_COLORS);
1565     ok( res == height, "got %d (bpp %d)\n", res, bpp );
1566
1567     /* Copy the DIB attributes but not the color table */
1568     memcpy(info2, info, sizeof(BITMAPINFOHEADER));
1569
1570     /* Select the DDB into another DC */
1571     old_bmp = SelectObject(ddb_dc, ddb);
1572
1573     /* Get the bits */
1574     res = GetDIBits(dc, ddb, 0, height, bits2, info2, DIB_RGB_COLORS);
1575     ok( res == height, "got %d (bpp %d)\n", res, bpp );
1576
1577     /* Compare the color table and the bits */
1578     if (bpp <= 8)
1579     {
1580         for (i=0; i < (1u << bpp); i++)
1581             ok( info->bmiColors[i].rgbRed      == info2->bmiColors[i].rgbRed   &&
1582                 info->bmiColors[i].rgbGreen    == info2->bmiColors[i].rgbGreen &&
1583                 info->bmiColors[i].rgbBlue     == info2->bmiColors[i].rgbBlue  &&
1584                 info->bmiColors[i].rgbReserved == info2->bmiColors[i].rgbReserved,
1585                 "color table entry %d differs (bpp %d)\n", i, bpp );
1586     }
1587
1588     ok( !memcmp( bits, bits2, info->bmiHeader.biSizeImage ), "bit mismatch (bpp %d)\n", bpp );
1589
1590     /* Test the palette */
1591     if (info2->bmiHeader.biBitCount <= 8)
1592     {
1593         WORD *colors = (WORD*)info2->bmiColors;
1594
1595         /* Get the palette indices */
1596         res = GetDIBits(dc, ddb, 0, 0, NULL, info2, DIB_PAL_COLORS);
1597         ok( res == 1, "got %d (bpp %d)\n", res, bpp );
1598
1599         for (i = 0; i < (1 << info->bmiHeader.biBitCount); i++)
1600             ok( colors[i] == i, "%d: got %d (bpp %d)\n", i, colors[i], bpp );
1601     }
1602
1603     HeapFree(GetProcessHeap(), 0, bits2);
1604     HeapFree(GetProcessHeap(), 0, bits);
1605     DeleteDC(dc);
1606
1607     SelectObject(ddb_dc, old_bmp);
1608     DeleteDC(ddb_dc);
1609     DeleteObject(ddb);
1610 }
1611
1612 static void test_GetDIBits(void)
1613 {
1614     /* 2-bytes aligned 1-bit bitmap data: 16x16 */
1615     static const BYTE bmp_bits_1[16 * 2] =
1616     {
1617         0xff,0xff, 0,0, 0xff,0xff, 0,0,
1618         0xff,0xff, 0,0, 0xff,0xff, 0,0,
1619         0xff,0xff, 0,0, 0xff,0xff, 0,0,
1620         0xff,0xff, 0,0, 0xff,0xff, 0,0
1621     };
1622     /* 4-bytes aligned 1-bit DIB data: 16x16 */
1623     static const BYTE dib_bits_1[16 * 4] =
1624     {
1625         0,0,0,0, 0xff,0xff,0,0, 0,0,0,0, 0xff,0xff,0,0,
1626         0,0,0,0, 0xff,0xff,0,0, 0,0,0,0, 0xff,0xff,0,0,
1627         0,0,0,0, 0xff,0xff,0,0, 0,0,0,0, 0xff,0xff,0,0,
1628         0,0,0,0, 0xff,0xff,0,0, 0,0,0,0, 0xff,0xff,0,0
1629     };
1630     /* 2-bytes aligned 24-bit bitmap data: 16x16 */
1631     static const BYTE bmp_bits_24[16 * 16*3] =
1632     {
1633         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1634         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1635         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1636         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1637         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1638         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1639         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1640         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1641         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1642         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1643         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1644         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1645         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1646         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1647         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1648         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1649         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1650         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1651         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1652         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1653         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1654         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1655         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1656         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1657         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1658         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1659         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1660         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1661         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1662         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1663         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1664         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
1665     };
1666     /* 4-bytes aligned 24-bit DIB data: 16x16 */
1667     static const BYTE dib_bits_24[16 * 16*3] =
1668     {
1669         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1670         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1671         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1672         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1673         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1674         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1675         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1676         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1677         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1678         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1679         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1680         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1681         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1682         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1683         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1684         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1685         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1686         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1687         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1688         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1689         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1690         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1691         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1692         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1693         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1694         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1695         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1696         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1697         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1698         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
1699         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
1700         0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff
1701     };
1702     HBITMAP hbmp;
1703     BITMAP bm;
1704     HDC hdc;
1705     int i, bytes, lines;
1706     BYTE buf[1024];
1707     char bi_buf[sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * 256];
1708     BITMAPINFO *bi = (BITMAPINFO *)bi_buf;
1709     PALETTEENTRY pal_ents[20];
1710
1711     hdc = GetDC(0);
1712
1713     /* 1-bit source bitmap data */
1714     hbmp = CreateBitmap(16, 16, 1, 1, bmp_bits_1);
1715     ok(hbmp != 0, "CreateBitmap failed\n");
1716
1717     memset(&bm, 0xAA, sizeof(bm));
1718     bytes = GetObject(hbmp, sizeof(bm), &bm);
1719     ok(bytes == sizeof(bm), "GetObject returned %d\n", bytes);
1720     ok(bm.bmType == 0, "wrong bmType %d\n", bm.bmType);
1721     ok(bm.bmWidth == 16, "wrong bmWidth %d\n", bm.bmWidth);
1722     ok(bm.bmHeight == 16, "wrong bmHeight %d\n", bm.bmHeight);
1723     ok(bm.bmWidthBytes == 2, "wrong bmWidthBytes %d\n", bm.bmWidthBytes);
1724     ok(bm.bmPlanes == 1, "wrong bmPlanes %u\n", bm.bmPlanes);
1725     ok(bm.bmBitsPixel == 1, "wrong bmBitsPixel %d\n", bm.bmBitsPixel);
1726     ok(!bm.bmBits, "wrong bmBits %p\n", bm.bmBits);
1727
1728     bytes = GetBitmapBits(hbmp, 0, NULL);
1729     ok(bytes == sizeof(bmp_bits_1), "expected 16*2 got %d bytes\n", bytes);
1730     bytes = GetBitmapBits(hbmp, sizeof(buf), buf);
1731     ok(bytes == sizeof(bmp_bits_1), "expected 16*2 got %d bytes\n", bytes);
1732     ok(!memcmp(buf, bmp_bits_1, sizeof(bmp_bits_1)), "bitmap bits don't match\n");
1733
1734     /* retrieve 1-bit DIB data */
1735     memset(bi, 0, sizeof(*bi));
1736     bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1737     bi->bmiHeader.biWidth = bm.bmWidth;
1738     bi->bmiHeader.biHeight = bm.bmHeight;
1739     bi->bmiHeader.biPlanes = 1;
1740     bi->bmiHeader.biBitCount = 1;
1741     bi->bmiHeader.biCompression = BI_RGB;
1742     bi->bmiHeader.biSizeImage = 0;
1743     memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1744     SetLastError(0xdeadbeef);
1745     lines = GetDIBits(0, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1746     ok(lines == 0, "GetDIBits copied %d lines with hdc = 0\n", lines);
1747     ok(GetLastError() == ERROR_INVALID_PARAMETER ||
1748        broken(GetLastError() == 0xdeadbeef), /* winnt */
1749        "wrong error %u\n", GetLastError());
1750     ok(bi->bmiHeader.biSizeImage == 0, "expected 0, got %u\n", bi->bmiHeader.biSizeImage);
1751
1752     memset(buf, 0xAA, sizeof(buf));
1753     SetLastError(0xdeadbeef);
1754     lines = GetDIBits(hdc, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1755     ok(lines == bm.bmHeight, "GetDIBits copied %d lines of %d, error %u\n",
1756        lines, bm.bmHeight, GetLastError());
1757     ok(bi->bmiHeader.biSizeImage == sizeof(dib_bits_1), "expected 16*4, got %u\n", bi->bmiHeader.biSizeImage);
1758
1759     /* the color table consists of black and white */
1760     ok(bi->bmiColors[0].rgbRed == 0 && bi->bmiColors[0].rgbGreen == 0 &&
1761        bi->bmiColors[0].rgbBlue == 0 && bi->bmiColors[0].rgbReserved == 0,
1762        "expected bmiColors[0] 0,0,0,0 - got %x %x %x %x\n",
1763        bi->bmiColors[0].rgbRed, bi->bmiColors[0].rgbGreen,
1764        bi->bmiColors[0].rgbBlue, bi->bmiColors[0].rgbReserved);
1765     ok(bi->bmiColors[1].rgbRed == 0xff && bi->bmiColors[1].rgbGreen == 0xff &&
1766        bi->bmiColors[1].rgbBlue == 0xff && bi->bmiColors[1].rgbReserved == 0,
1767        "expected bmiColors[0] 0xff,0xff,0xff,0 - got %x %x %x %x\n",
1768        bi->bmiColors[1].rgbRed, bi->bmiColors[1].rgbGreen,
1769        bi->bmiColors[1].rgbBlue, bi->bmiColors[1].rgbReserved);
1770     for (i = 2; i < 256; i++)
1771     {
1772         ok(bi->bmiColors[i].rgbRed == 0xAA && bi->bmiColors[i].rgbGreen == 0xAA &&
1773            bi->bmiColors[i].rgbBlue == 0xAA && bi->bmiColors[i].rgbReserved == 0xAA,
1774            "expected bmiColors[%d] 0xAA,0xAA,0xAA,0xAA - got %x %x %x %x\n", i,
1775            bi->bmiColors[i].rgbRed, bi->bmiColors[i].rgbGreen,
1776            bi->bmiColors[i].rgbBlue, bi->bmiColors[i].rgbReserved);
1777     }
1778
1779     /* returned bits are DWORD aligned and upside down */
1780     ok(!memcmp(buf, dib_bits_1, sizeof(dib_bits_1)), "DIB bits don't match\n");
1781
1782     /* Test the palette indices */
1783     memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1784     SetLastError(0xdeadbeef);
1785     lines = GetDIBits(hdc, hbmp, 0, 0, NULL, bi, DIB_PAL_COLORS);
1786     ok(((WORD*)bi->bmiColors)[0] == 0, "Color 0 is %d\n", ((WORD*)bi->bmiColors)[0]);
1787     ok(((WORD*)bi->bmiColors)[1] == 1, "Color 1 is %d\n", ((WORD*)bi->bmiColors)[1]);
1788     for (i = 2; i < 256; i++)
1789         ok(((WORD*)bi->bmiColors)[i] == 0xAAAA, "Color %d is %d\n", i, ((WORD*)bi->bmiColors)[1]);
1790
1791     /* retrieve 24-bit DIB data */
1792     memset(bi, 0, sizeof(*bi));
1793     bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1794     bi->bmiHeader.biWidth = bm.bmWidth;
1795     bi->bmiHeader.biHeight = bm.bmHeight;
1796     bi->bmiHeader.biPlanes = 1;
1797     bi->bmiHeader.biBitCount = 24;
1798     bi->bmiHeader.biCompression = BI_RGB;
1799     bi->bmiHeader.biSizeImage = 0;
1800     memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1801     memset(buf, 0xAA, sizeof(buf));
1802     SetLastError(0xdeadbeef);
1803     lines = GetDIBits(hdc, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1804     ok(lines == bm.bmHeight, "GetDIBits copied %d lines of %d, error %u\n",
1805        lines, bm.bmHeight, GetLastError());
1806     ok(bi->bmiHeader.biSizeImage == sizeof(dib_bits_24), "expected 16*16*3, got %u\n", bi->bmiHeader.biSizeImage);
1807
1808     /* the color table doesn't exist for 24-bit images */
1809     for (i = 0; i < 256; i++)
1810     {
1811         ok(bi->bmiColors[i].rgbRed == 0xAA && bi->bmiColors[i].rgbGreen == 0xAA &&
1812            bi->bmiColors[i].rgbBlue == 0xAA && bi->bmiColors[i].rgbReserved == 0xAA,
1813            "expected bmiColors[%d] 0xAA,0xAA,0xAA,0xAA - got %x %x %x %x\n", i,
1814            bi->bmiColors[i].rgbRed, bi->bmiColors[i].rgbGreen,
1815            bi->bmiColors[i].rgbBlue, bi->bmiColors[i].rgbReserved);
1816     }
1817
1818     /* returned bits are DWORD aligned and upside down */
1819     ok(!memcmp(buf, dib_bits_24, sizeof(dib_bits_24)), "DIB bits don't match\n");
1820     DeleteObject(hbmp);
1821
1822     /* 24-bit source bitmap data */
1823     hbmp = CreateCompatibleBitmap(hdc, 16, 16);
1824     ok(hbmp != 0, "CreateBitmap failed\n");
1825     SetLastError(0xdeadbeef);
1826     bi->bmiHeader.biHeight = -bm.bmHeight; /* indicate bottom-up data */
1827     lines = SetDIBits(hdc, hbmp, 0, bm.bmHeight, bmp_bits_24, bi, DIB_RGB_COLORS);
1828     ok(lines == bm.bmHeight, "SetDIBits copied %d lines of %d, error %u\n",
1829        lines, bm.bmHeight, GetLastError());
1830
1831     memset(&bm, 0xAA, sizeof(bm));
1832     bytes = GetObject(hbmp, sizeof(bm), &bm);
1833     ok(bytes == sizeof(bm), "GetObject returned %d\n", bytes);
1834     ok(bm.bmType == 0, "wrong bmType %d\n", bm.bmType);
1835     ok(bm.bmWidth == 16, "wrong bmWidth %d\n", bm.bmWidth);
1836     ok(bm.bmHeight == 16, "wrong bmHeight %d\n", bm.bmHeight);
1837     ok(bm.bmWidthBytes == BITMAP_GetWidthBytes(bm.bmWidth, bm.bmBitsPixel), "wrong bmWidthBytes %d\n", bm.bmWidthBytes);
1838     ok(bm.bmPlanes == GetDeviceCaps(hdc, PLANES), "wrong bmPlanes %u\n", bm.bmPlanes);
1839     ok(bm.bmBitsPixel == GetDeviceCaps(hdc, BITSPIXEL), "wrong bmBitsPixel %d\n", bm.bmBitsPixel);
1840     ok(!bm.bmBits, "wrong bmBits %p\n", bm.bmBits);
1841
1842     bytes = GetBitmapBits(hbmp, 0, NULL);
1843     ok(bytes == bm.bmWidthBytes * bm.bmHeight, "expected %d got %d bytes\n", bm.bmWidthBytes * bm.bmHeight, bytes);
1844     bytes = GetBitmapBits(hbmp, sizeof(buf), buf);
1845     ok(bytes == bm.bmWidthBytes * bm.bmHeight, "expected %d got %d bytes\n",
1846        bm.bmWidthBytes * bm.bmHeight, bytes);
1847
1848     /* retrieve 1-bit DIB data */
1849     memset(bi, 0, sizeof(*bi));
1850     bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1851     bi->bmiHeader.biWidth = bm.bmWidth;
1852     bi->bmiHeader.biHeight = bm.bmHeight;
1853     bi->bmiHeader.biPlanes = 1;
1854     bi->bmiHeader.biBitCount = 1;
1855     bi->bmiHeader.biCompression = BI_RGB;
1856     bi->bmiHeader.biSizeImage = 0;
1857     memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1858     memset(buf, 0xAA, sizeof(buf));
1859     SetLastError(0xdeadbeef);
1860     lines = GetDIBits(hdc, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1861     ok(lines == bm.bmHeight, "GetDIBits copied %d lines of %d, error %u\n",
1862        lines, bm.bmHeight, GetLastError());
1863     ok(bi->bmiHeader.biSizeImage == sizeof(dib_bits_1), "expected 16*4, got %u\n", bi->bmiHeader.biSizeImage);
1864
1865     /* the color table consists of black and white */
1866     ok(bi->bmiColors[0].rgbRed == 0 && bi->bmiColors[0].rgbGreen == 0 &&
1867        bi->bmiColors[0].rgbBlue == 0 && bi->bmiColors[0].rgbReserved == 0,
1868        "expected bmiColors[0] 0,0,0,0 - got %x %x %x %x\n",
1869        bi->bmiColors[0].rgbRed, bi->bmiColors[0].rgbGreen,
1870        bi->bmiColors[0].rgbBlue, bi->bmiColors[0].rgbReserved);
1871     ok(bi->bmiColors[1].rgbRed == 0xff && bi->bmiColors[1].rgbGreen == 0xff &&
1872        bi->bmiColors[1].rgbBlue == 0xff && bi->bmiColors[1].rgbReserved == 0,
1873        "expected bmiColors[0] 0xff,0xff,0xff,0 - got %x %x %x %x\n",
1874        bi->bmiColors[1].rgbRed, bi->bmiColors[1].rgbGreen,
1875        bi->bmiColors[1].rgbBlue, bi->bmiColors[1].rgbReserved);
1876     for (i = 2; i < 256; i++)
1877     {
1878         ok(bi->bmiColors[i].rgbRed == 0xAA && bi->bmiColors[i].rgbGreen == 0xAA &&
1879            bi->bmiColors[i].rgbBlue == 0xAA && bi->bmiColors[i].rgbReserved == 0xAA,
1880            "expected bmiColors[%d] 0xAA,0xAA,0xAA,0xAA - got %x %x %x %x\n", i,
1881            bi->bmiColors[i].rgbRed, bi->bmiColors[i].rgbGreen,
1882            bi->bmiColors[i].rgbBlue, bi->bmiColors[i].rgbReserved);
1883     }
1884
1885     /* returned bits are DWORD aligned and upside down */
1886     ok(!memcmp(buf, dib_bits_1, sizeof(dib_bits_1)), "DIB bits don't match\n");
1887
1888     /* Test the palette indices */
1889     memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1890     SetLastError(0xdeadbeef);
1891     lines = GetDIBits(hdc, hbmp, 0, 0, NULL, bi, DIB_PAL_COLORS);
1892     ok(((WORD*)bi->bmiColors)[0] == 0, "Color 0 is %d\n", ((WORD*)bi->bmiColors)[0]);
1893     ok(((WORD*)bi->bmiColors)[1] == 1, "Color 1 is %d\n", ((WORD*)bi->bmiColors)[1]);
1894     for (i = 2; i < 256; i++)
1895         ok(((WORD*)bi->bmiColors)[i] == 0xAAAA, "Color %d is %d\n", i, ((WORD*)bi->bmiColors)[i]);
1896
1897     /* retrieve 4-bit DIB data */
1898     memset(bi, 0, sizeof(*bi));
1899     bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1900     bi->bmiHeader.biWidth = bm.bmWidth;
1901     bi->bmiHeader.biHeight = bm.bmHeight;
1902     bi->bmiHeader.biPlanes = 1;
1903     bi->bmiHeader.biBitCount = 4;
1904     bi->bmiHeader.biCompression = BI_RGB;
1905     bi->bmiHeader.biSizeImage = 0;
1906     memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1907     memset(buf, 0xAA, sizeof(buf));
1908     SetLastError(0xdeadbeef);
1909     lines = GetDIBits(hdc, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1910     ok(lines == bm.bmHeight, "GetDIBits copied %d lines of %d, error %u\n",
1911        lines, bm.bmHeight, GetLastError());
1912
1913     GetPaletteEntries( GetStockObject(DEFAULT_PALETTE), 0, 20, pal_ents );
1914
1915     for (i = 0; i < 16; i++)
1916     {
1917         RGBQUAD expect;
1918         int entry = i < 8 ? i : i + 4;
1919
1920         if(entry == 7) entry = 12;
1921         else if(entry == 12) entry = 7;
1922
1923         expect.rgbRed   = pal_ents[entry].peRed;
1924         expect.rgbGreen = pal_ents[entry].peGreen;
1925         expect.rgbBlue  = pal_ents[entry].peBlue;
1926         expect.rgbReserved = 0;
1927
1928         ok(!memcmp(bi->bmiColors + i, &expect, sizeof(expect)),
1929            "expected bmiColors[%d] %x %x %x %x - got %x %x %x %x\n", i,
1930            expect.rgbRed, expect.rgbGreen, expect.rgbBlue, expect.rgbReserved,
1931            bi->bmiColors[i].rgbRed, bi->bmiColors[i].rgbGreen,
1932            bi->bmiColors[i].rgbBlue, bi->bmiColors[i].rgbReserved);
1933     }
1934
1935     /* retrieve 8-bit DIB data */
1936     memset(bi, 0, sizeof(*bi));
1937     bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1938     bi->bmiHeader.biWidth = bm.bmWidth;
1939     bi->bmiHeader.biHeight = bm.bmHeight;
1940     bi->bmiHeader.biPlanes = 1;
1941     bi->bmiHeader.biBitCount = 8;
1942     bi->bmiHeader.biCompression = BI_RGB;
1943     bi->bmiHeader.biSizeImage = 0;
1944     memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1945     memset(buf, 0xAA, sizeof(buf));
1946     SetLastError(0xdeadbeef);
1947     lines = GetDIBits(hdc, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1948     ok(lines == bm.bmHeight, "GetDIBits copied %d lines of %d, error %u\n",
1949        lines, bm.bmHeight, GetLastError());
1950
1951     GetPaletteEntries( GetStockObject(DEFAULT_PALETTE), 0, 20, pal_ents );
1952
1953     for (i = 0; i < 256; i++)
1954     {
1955         RGBQUAD expect;
1956
1957         if (i < 10 || i >= 246)
1958         {
1959             int entry = i < 10 ? i : i - 236;
1960             expect.rgbRed   = pal_ents[entry].peRed;
1961             expect.rgbGreen = pal_ents[entry].peGreen;
1962             expect.rgbBlue  = pal_ents[entry].peBlue;
1963         }
1964         else
1965         {
1966             expect.rgbRed   = (i & 0x07) << 5;
1967             expect.rgbGreen = (i & 0x38) << 2;
1968             expect.rgbBlue  =  i & 0xc0;
1969         }
1970         expect.rgbReserved = 0;
1971
1972         ok(!memcmp(bi->bmiColors + i, &expect, sizeof(expect)),
1973            "expected bmiColors[%d] %x %x %x %x - got %x %x %x %x\n", i,
1974            expect.rgbRed, expect.rgbGreen, expect.rgbBlue, expect.rgbReserved,
1975            bi->bmiColors[i].rgbRed, bi->bmiColors[i].rgbGreen,
1976            bi->bmiColors[i].rgbBlue, bi->bmiColors[i].rgbReserved);
1977     }
1978
1979     /* retrieve 24-bit DIB data */
1980     memset(bi, 0, sizeof(*bi));
1981     bi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
1982     bi->bmiHeader.biWidth = bm.bmWidth;
1983     bi->bmiHeader.biHeight = bm.bmHeight;
1984     bi->bmiHeader.biPlanes = 1;
1985     bi->bmiHeader.biBitCount = 24;
1986     bi->bmiHeader.biCompression = BI_RGB;
1987     bi->bmiHeader.biSizeImage = 0;
1988     memset(bi->bmiColors, 0xAA, sizeof(RGBQUAD) * 256);
1989     memset(buf, 0xAA, sizeof(buf));
1990     SetLastError(0xdeadbeef);
1991     lines = GetDIBits(hdc, hbmp, 0, bm.bmHeight, buf, bi, DIB_RGB_COLORS);
1992     ok(lines == bm.bmHeight, "GetDIBits copied %d lines of %d, error %u\n",
1993        lines, bm.bmHeight, GetLastError());
1994     ok(bi->bmiHeader.biSizeImage == sizeof(dib_bits_24), "expected 16*16*3, got %u\n", bi->bmiHeader.biSizeImage);
1995
1996     /* the color table doesn't exist for 24-bit images */
1997     for (i = 0; i < 256; i++)
1998     {
1999         ok(bi->bmiColors[i].rgbRed == 0xAA && bi->bmiColors[i].rgbGreen == 0xAA &&
2000            bi->bmiColors[i].rgbBlue == 0xAA && bi->bmiColors[i].rgbReserved == 0xAA,
2001            "expected bmiColors[%d] 0xAA,0xAA,0xAA,0xAA - got %x %x %x %x\n", i,
2002            bi->bmiColors[i].rgbRed, bi->bmiColors[i].rgbGreen,
2003            bi->bmiColors[i].rgbBlue, bi->bmiColors[i].rgbReserved);
2004     }
2005
2006     /* returned bits are DWORD aligned and upside down */
2007     ok(!memcmp(buf, dib_bits_24, sizeof(dib_bits_24)), "DIB bits don't match\n");
2008     DeleteObject(hbmp);
2009
2010     ReleaseDC(0, hdc);
2011 }
2012
2013 static void test_GetDIBits_BI_BITFIELDS(void)
2014 {
2015     /* Try a screen resolution detection technique
2016      * from the September 1999 issue of Windows Developer's Journal
2017      * which seems to be in widespread use.
2018      * http://www.lesher.ws/highcolor.html
2019      * http://www.lesher.ws/vidfmt.c
2020      * It hinges on being able to retrieve the bitmaps
2021      * for the three primary colors in non-paletted 16 bit mode.
2022      */
2023     char dibinfo_buf[sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD)];
2024     DWORD bits[32];
2025     LPBITMAPINFO dibinfo = (LPBITMAPINFO) dibinfo_buf;
2026     DWORD *bitmasks = (DWORD *)dibinfo->bmiColors;
2027     HDC hdc;
2028     HBITMAP hbm;
2029     int ret;
2030     void *ptr;
2031
2032     memset(dibinfo, 0, sizeof(dibinfo_buf));
2033     dibinfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2034
2035     hdc = GetDC(NULL);
2036     ok(hdc != NULL, "GetDC failed?\n");
2037     hbm = CreateCompatibleBitmap(hdc, 1, 1);
2038     ok(hbm != NULL, "CreateCompatibleBitmap failed?\n");
2039
2040     /* Call GetDIBits to fill in bmiHeader.  */
2041     ret = GetDIBits(hdc, hbm, 0, 1, NULL, dibinfo, DIB_RGB_COLORS);
2042     ok(ret == 1, "GetDIBits failed\n");
2043     if (dibinfo->bmiHeader.biBitCount > 8)
2044     {
2045         ok( dibinfo->bmiHeader.biCompression == BI_BITFIELDS ||
2046             broken( dibinfo->bmiHeader.biCompression == BI_RGB ), /* nt4 sp3 */
2047             "compression is %u (%d bpp)\n", dibinfo->bmiHeader.biCompression, dibinfo->bmiHeader.biBitCount );
2048
2049         if (dibinfo->bmiHeader.biCompression == BI_BITFIELDS)
2050         {
2051             ok( !bitmasks[0], "red mask is set\n" );
2052             ok( !bitmasks[1], "green mask is set\n" );
2053             ok( !bitmasks[2], "blue mask is set\n" );
2054
2055             /* test with NULL bits pointer and correct bpp */
2056             dibinfo->bmiHeader.biSizeImage = 0xdeadbeef;
2057             ret = GetDIBits(hdc, hbm, 0, 1, NULL, dibinfo, DIB_RGB_COLORS);
2058             ok(ret == 1, "GetDIBits failed\n");
2059
2060             ok( bitmasks[0] != 0, "red mask is not set\n" );
2061             ok( bitmasks[1] != 0, "green mask is not set\n" );
2062             ok( bitmasks[2] != 0, "blue mask is not set\n" );
2063             ok( dibinfo->bmiHeader.biSizeImage != 0xdeadbeef, "size image not set\n" );
2064
2065             /* test with valid bits pointer */
2066             memset(dibinfo, 0, sizeof(dibinfo_buf));
2067             dibinfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2068             ret = GetDIBits(hdc, hbm, 0, 1, NULL, dibinfo, DIB_RGB_COLORS);
2069             ok(ret == 1, "GetDIBits failed ret %u err %u\n",ret,GetLastError());
2070             dibinfo->bmiHeader.biSizeImage = 0xdeadbeef;
2071             ret = GetDIBits(hdc, hbm, 0, 1, bits, dibinfo, DIB_RGB_COLORS);
2072             ok(ret == 1, "GetDIBits failed ret %u err %u\n",ret,GetLastError());
2073
2074             ok( bitmasks[0] != 0, "red mask is not set\n" );
2075             ok( bitmasks[1] != 0, "green mask is not set\n" );
2076             ok( bitmasks[2] != 0, "blue mask is not set\n" );
2077             ok( dibinfo->bmiHeader.biSizeImage != 0xdeadbeef, "size image not set\n" );
2078
2079             /* now with bits and 0 lines */
2080             memset(dibinfo, 0, sizeof(dibinfo_buf));
2081             dibinfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2082             dibinfo->bmiHeader.biSizeImage = 0xdeadbeef;
2083             SetLastError(0xdeadbeef);
2084             ret = GetDIBits(hdc, hbm, 0, 0, bits, dibinfo, DIB_RGB_COLORS);
2085             ok(ret == 1, "GetDIBits failed ret %u err %u\n",ret,GetLastError());
2086
2087             ok( !bitmasks[0], "red mask is set\n" );
2088             ok( !bitmasks[1], "green mask is set\n" );
2089             ok( !bitmasks[2], "blue mask is set\n" );
2090             ok( dibinfo->bmiHeader.biSizeImage != 0xdeadbeef, "size image not set\n" );
2091
2092             memset(bitmasks, 0, 3*sizeof(DWORD));
2093             dibinfo->bmiHeader.biSizeImage = 0xdeadbeef;
2094             ret = GetDIBits(hdc, hbm, 0, 0, bits, dibinfo, DIB_RGB_COLORS);
2095             ok(ret == 1, "GetDIBits failed ret %u err %u\n",ret,GetLastError());
2096
2097             ok( bitmasks[0] != 0, "red mask is not set\n" );
2098             ok( bitmasks[1] != 0, "green mask is not set\n" );
2099             ok( bitmasks[2] != 0, "blue mask is not set\n" );
2100             ok( dibinfo->bmiHeader.biSizeImage != 0xdeadbeef, "size image not set\n" );
2101         }
2102     }
2103     else skip("bitmap in colortable mode, skipping BI_BITFIELDS tests\n");
2104
2105     DeleteObject(hbm);
2106
2107     /* same thing now with a 32-bpp DIB section */
2108
2109     dibinfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2110     dibinfo->bmiHeader.biWidth = 1;
2111     dibinfo->bmiHeader.biHeight = 1;
2112     dibinfo->bmiHeader.biPlanes = 1;
2113     dibinfo->bmiHeader.biBitCount = 32;
2114     dibinfo->bmiHeader.biCompression = BI_RGB;
2115     dibinfo->bmiHeader.biSizeImage = 0;
2116     dibinfo->bmiHeader.biXPelsPerMeter = 0;
2117     dibinfo->bmiHeader.biYPelsPerMeter = 0;
2118     dibinfo->bmiHeader.biClrUsed = 0;
2119     dibinfo->bmiHeader.biClrImportant = 0;
2120     bitmasks[0] = 0x0000ff;
2121     bitmasks[1] = 0x00ff00;
2122     bitmasks[2] = 0xff0000;
2123     hbm = CreateDIBSection( hdc, dibinfo, DIB_RGB_COLORS, &ptr, NULL, 0 );
2124     ok( hbm != 0, "failed to create bitmap\n" );
2125
2126     memset(dibinfo, 0, sizeof(dibinfo_buf));
2127     dibinfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2128     ret = GetDIBits(hdc, hbm, 0, 0, NULL, dibinfo, DIB_RGB_COLORS);
2129     ok(ret == 1, "GetDIBits failed\n");
2130     ok( dibinfo->bmiHeader.biBitCount == 32, "wrong bit count %u\n", dibinfo->bmiHeader.biBitCount );
2131
2132     ok( dibinfo->bmiHeader.biCompression == BI_BITFIELDS ||
2133         broken( dibinfo->bmiHeader.biCompression == BI_RGB ), /* nt4 sp3 */
2134         "compression is %u\n", dibinfo->bmiHeader.biCompression );
2135     ok( !bitmasks[0], "red mask is set\n" );
2136     ok( !bitmasks[1], "green mask is set\n" );
2137     ok( !bitmasks[2], "blue mask is set\n" );
2138
2139     dibinfo->bmiHeader.biSizeImage = 0xdeadbeef;
2140     ret = GetDIBits(hdc, hbm, 0, 1, bits, dibinfo, DIB_RGB_COLORS);
2141     ok(ret == 1, "GetDIBits failed\n");
2142     ok( dibinfo->bmiHeader.biBitCount == 32, "wrong bit count %u\n", dibinfo->bmiHeader.biBitCount );
2143     ok( dibinfo->bmiHeader.biCompression == BI_BITFIELDS ||
2144         broken( dibinfo->bmiHeader.biCompression == BI_RGB ), /* nt4 sp3 */
2145         "compression is %u\n", dibinfo->bmiHeader.biCompression );
2146     if (dibinfo->bmiHeader.biCompression == BI_BITFIELDS)
2147     {
2148         ok( bitmasks[0] == 0xff0000, "wrong red mask %08x\n", bitmasks[0] );
2149         ok( bitmasks[1] == 0x00ff00, "wrong green mask %08x\n", bitmasks[1] );
2150         ok( bitmasks[2] == 0x0000ff, "wrong blue mask %08x\n", bitmasks[2] );
2151     }
2152     ok( dibinfo->bmiHeader.biSizeImage != 0xdeadbeef, "size image not set\n" );
2153
2154     DeleteObject(hbm);
2155
2156     dibinfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2157     dibinfo->bmiHeader.biWidth = 1;
2158     dibinfo->bmiHeader.biHeight = 1;
2159     dibinfo->bmiHeader.biPlanes = 1;
2160     dibinfo->bmiHeader.biBitCount = 32;
2161     dibinfo->bmiHeader.biCompression = BI_BITFIELDS;
2162     dibinfo->bmiHeader.biSizeImage = 0;
2163     dibinfo->bmiHeader.biXPelsPerMeter = 0;
2164     dibinfo->bmiHeader.biYPelsPerMeter = 0;
2165     dibinfo->bmiHeader.biClrUsed = 0;
2166     dibinfo->bmiHeader.biClrImportant = 0;
2167     bitmasks[0] = 0x0000ff;
2168     bitmasks[1] = 0x00ff00;
2169     bitmasks[2] = 0xff0000;
2170     hbm = CreateDIBSection( hdc, dibinfo, DIB_RGB_COLORS, &ptr, NULL, 0 );
2171     ok( hbm != 0, "failed to create bitmap\n" );
2172
2173     if (hbm)
2174     {
2175         memset(dibinfo, 0, sizeof(dibinfo_buf));
2176         dibinfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2177         ret = GetDIBits(hdc, hbm, 0, 0, NULL, dibinfo, DIB_RGB_COLORS);
2178         ok(ret == 1, "GetDIBits failed\n");
2179
2180         ok( dibinfo->bmiHeader.biCompression == BI_BITFIELDS,
2181             "compression is %u\n", dibinfo->bmiHeader.biCompression );
2182         ok( !bitmasks[0], "red mask is set\n" );
2183         ok( !bitmasks[1], "green mask is set\n" );
2184         ok( !bitmasks[2], "blue mask is set\n" );
2185
2186         dibinfo->bmiHeader.biSizeImage = 0xdeadbeef;
2187         ret = GetDIBits(hdc, hbm, 0, 1, bits, dibinfo, DIB_RGB_COLORS);
2188         ok(ret == 1, "GetDIBits failed\n");
2189         ok( bitmasks[0] == 0x0000ff, "wrong red mask %08x\n", bitmasks[0] );
2190         ok( bitmasks[1] == 0x00ff00, "wrong green mask %08x\n", bitmasks[1] );
2191         ok( bitmasks[2] == 0xff0000, "wrong blue mask %08x\n", bitmasks[2] );
2192         ok( dibinfo->bmiHeader.biSizeImage != 0xdeadbeef, "size image not set\n" );
2193
2194         DeleteObject(hbm);
2195     }
2196
2197     /* 24-bpp DIB sections don't have bitfields */
2198
2199     dibinfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2200     dibinfo->bmiHeader.biWidth = 1;
2201     dibinfo->bmiHeader.biHeight = 1;
2202     dibinfo->bmiHeader.biPlanes = 1;
2203     dibinfo->bmiHeader.biBitCount = 24;
2204     dibinfo->bmiHeader.biCompression = BI_BITFIELDS;
2205     dibinfo->bmiHeader.biSizeImage = 0;
2206     dibinfo->bmiHeader.biXPelsPerMeter = 0;
2207     dibinfo->bmiHeader.biYPelsPerMeter = 0;
2208     dibinfo->bmiHeader.biClrUsed = 0;
2209     dibinfo->bmiHeader.biClrImportant = 0;
2210     hbm = CreateDIBSection( hdc, dibinfo, DIB_RGB_COLORS, &ptr, NULL, 0 );
2211     ok( hbm == 0, "creating 24-bpp BI_BITFIELDS dibsection should fail\n" );
2212     dibinfo->bmiHeader.biCompression = BI_RGB;
2213     hbm = CreateDIBSection( hdc, dibinfo, DIB_RGB_COLORS, &ptr, NULL, 0 );
2214     ok( hbm != 0, "failed to create bitmap\n" );
2215
2216     memset(dibinfo, 0, sizeof(dibinfo_buf));
2217     dibinfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2218     ret = GetDIBits(hdc, hbm, 0, 0, NULL, dibinfo, DIB_RGB_COLORS);
2219     ok(ret == 1, "GetDIBits failed\n");
2220     ok( dibinfo->bmiHeader.biBitCount == 24, "wrong bit count %u\n", dibinfo->bmiHeader.biBitCount );
2221
2222     ok( dibinfo->bmiHeader.biCompression == BI_RGB,
2223         "compression is %u\n", dibinfo->bmiHeader.biCompression );
2224     ok( !bitmasks[0], "red mask is set\n" );
2225     ok( !bitmasks[1], "green mask is set\n" );
2226     ok( !bitmasks[2], "blue mask is set\n" );
2227
2228     dibinfo->bmiHeader.biSizeImage = 0xdeadbeef;
2229     ret = GetDIBits(hdc, hbm, 0, 1, bits, dibinfo, DIB_RGB_COLORS);
2230     ok(ret == 1, "GetDIBits failed\n");
2231     ok( dibinfo->bmiHeader.biBitCount == 24, "wrong bit count %u\n", dibinfo->bmiHeader.biBitCount );
2232     ok( !bitmasks[0], "red mask is set\n" );
2233     ok( !bitmasks[1], "green mask is set\n" );
2234     ok( !bitmasks[2], "blue mask is set\n" );
2235     ok( dibinfo->bmiHeader.biSizeImage != 0xdeadbeef, "size image not set\n" );
2236
2237     DeleteObject(hbm);
2238     ReleaseDC(NULL, hdc);
2239 }
2240
2241 static void test_select_object(void)
2242 {
2243     HDC hdc;
2244     HBITMAP hbm, hbm_old;
2245     INT planes, bpp, i;
2246     DWORD depths[] = {8, 15, 16, 24, 32};
2247     BITMAP bm;
2248     DWORD bytes;
2249
2250     hdc = GetDC(0);
2251     ok(hdc != 0, "GetDC(0) failed\n");
2252     hbm = CreateCompatibleBitmap(hdc, 10, 10);
2253     ok(hbm != 0, "CreateCompatibleBitmap failed\n");
2254
2255     hbm_old = SelectObject(hdc, hbm);
2256     ok(hbm_old == 0, "SelectObject should fail\n");
2257
2258     DeleteObject(hbm);
2259     ReleaseDC(0, hdc);
2260
2261     hdc = CreateCompatibleDC(0);
2262     ok(hdc != 0, "GetDC(0) failed\n");
2263     hbm = CreateCompatibleBitmap(hdc, 10, 10);
2264     ok(hbm != 0, "CreateCompatibleBitmap failed\n");
2265
2266     hbm_old = SelectObject(hdc, hbm);
2267     ok(hbm_old != 0, "SelectObject failed\n");
2268     hbm_old = SelectObject(hdc, hbm_old);
2269     ok(hbm_old == hbm, "SelectObject failed\n");
2270
2271     DeleteObject(hbm);
2272
2273     /* test an 1-bpp bitmap */
2274     planes = GetDeviceCaps(hdc, PLANES);
2275     bpp = 1;
2276
2277     hbm = CreateBitmap(10, 10, planes, bpp, NULL);
2278     ok(hbm != 0, "CreateBitmap failed\n");
2279
2280     hbm_old = SelectObject(hdc, hbm);
2281     ok(hbm_old != 0, "SelectObject failed\n");
2282     hbm_old = SelectObject(hdc, hbm_old);
2283     ok(hbm_old == hbm, "SelectObject failed\n");
2284
2285     DeleteObject(hbm);
2286
2287     for(i = 0; i < sizeof(depths)/sizeof(depths[0]); i++) {
2288         /* test a color bitmap to dc bpp matching */
2289         planes = GetDeviceCaps(hdc, PLANES);
2290         bpp = GetDeviceCaps(hdc, BITSPIXEL);
2291
2292         hbm = CreateBitmap(10, 10, planes, depths[i], NULL);
2293         ok(hbm != 0, "CreateBitmap failed\n");
2294
2295         hbm_old = SelectObject(hdc, hbm);
2296         if(depths[i] == bpp ||
2297           (bpp == 16 && depths[i] == 15)        /* 16 and 15 bpp are compatible */
2298           ) {
2299             ok(hbm_old != 0, "SelectObject failed, BITSPIXEL: %d, created depth: %d\n", bpp, depths[i]);
2300             SelectObject(hdc, hbm_old);
2301         } else {
2302             ok(hbm_old == 0, "SelectObject should fail. BITSPIXELS: %d, created depth: %d\n", bpp, depths[i]);
2303         }
2304
2305         memset(&bm, 0xAA, sizeof(bm));
2306         bytes = GetObject(hbm, sizeof(bm), &bm);
2307         ok(bytes == sizeof(bm), "GetObject returned %d\n", bytes);
2308         ok(bm.bmType == 0, "wrong bmType %d\n", bm.bmType);
2309         ok(bm.bmWidth == 10, "wrong bmWidth %d\n", bm.bmWidth);
2310         ok(bm.bmHeight == 10, "wrong bmHeight %d\n", bm.bmHeight);
2311         ok(bm.bmWidthBytes == BITMAP_GetWidthBytes(bm.bmWidth, bm.bmBitsPixel), "wrong bmWidthBytes %d\n", bm.bmWidthBytes);
2312         ok(bm.bmPlanes == planes, "wrong bmPlanes %u\n", bm.bmPlanes);
2313         if(depths[i] == 15) {
2314             ok(bm.bmBitsPixel == 16, "wrong bmBitsPixel %d(15 bpp special)\n", bm.bmBitsPixel);
2315         } else {
2316             ok(bm.bmBitsPixel == depths[i], "wrong bmBitsPixel %d\n", bm.bmBitsPixel);
2317         }
2318         ok(!bm.bmBits, "wrong bmBits %p\n", bm.bmBits);
2319
2320         DeleteObject(hbm);
2321     }
2322
2323     DeleteDC(hdc);
2324 }
2325
2326 static void test_mono_1x1_bmp_dbg(HBITMAP hbmp, int line)
2327 {
2328     INT ret;
2329     BITMAP bm;
2330
2331     ret = GetObjectType(hbmp);
2332     ok_(__FILE__, line)(ret == OBJ_BITMAP, "the object %p is not bitmap\n", hbmp);
2333
2334     ret = GetObject(hbmp, 0, 0);
2335     ok_(__FILE__, line)(ret == sizeof(BITMAP), "object size %d\n", ret);
2336
2337     memset(&bm, 0xDA, sizeof(bm));
2338     SetLastError(0xdeadbeef);
2339     ret = GetObject(hbmp, sizeof(bm), &bm);
2340     if (!ret) /* XP, only for curObj2 */ return;
2341     ok_(__FILE__, line)(ret == sizeof(BITMAP), "GetObject returned %d, error %u\n", ret, GetLastError());
2342     ok_(__FILE__, line)(bm.bmType == 0, "wrong bmType, expected 0 got %d\n", bm.bmType);
2343     ok_(__FILE__, line)(bm.bmWidth == 1, "wrong bmWidth, expected 1 got %d\n", bm.bmWidth);
2344     ok_(__FILE__, line)(bm.bmHeight == 1, "wrong bmHeight, expected 1 got %d\n", bm.bmHeight);
2345     ok_(__FILE__, line)(bm.bmWidthBytes == 2, "wrong bmWidthBytes, expected 2 got %d\n", bm.bmWidthBytes);
2346     ok_(__FILE__, line)(bm.bmPlanes == 1, "wrong bmPlanes, expected 1 got %u\n", bm.bmPlanes);
2347     ok_(__FILE__, line)(bm.bmBitsPixel == 1, "wrong bmBitsPixel, expected 1 got %d\n", bm.bmBitsPixel);
2348     ok_(__FILE__, line)(!bm.bmBits, "wrong bmBits %p\n", bm.bmBits);
2349 }
2350
2351 #define test_mono_1x1_bmp(a) test_mono_1x1_bmp_dbg((a), __LINE__)
2352
2353 static void test_CreateBitmap(void)
2354 {
2355     BITMAP bmp;
2356     HDC screenDC = GetDC(0);
2357     HDC hdc = CreateCompatibleDC(screenDC);
2358     UINT i, expect = 0;
2359
2360     /* all of these are the stock monochrome bitmap */
2361     HBITMAP bm = CreateCompatibleBitmap(hdc, 0, 0);
2362     HBITMAP bm1 = CreateCompatibleBitmap(screenDC, 0, 0);
2363     HBITMAP bm4 = CreateBitmap(0, 1, 0, 0, 0);
2364     HBITMAP bm5 = CreateDiscardableBitmap(hdc, 0, 0);
2365     HBITMAP curObj1 = GetCurrentObject(hdc, OBJ_BITMAP);
2366     HBITMAP curObj2 = GetCurrentObject(screenDC, OBJ_BITMAP);
2367
2368     /* these 2 are not the stock monochrome bitmap */
2369     HBITMAP bm2 = CreateCompatibleBitmap(hdc, 1, 1);
2370     HBITMAP bm3 = CreateBitmap(1, 1, 1, 1, 0);
2371
2372     HBITMAP old1 = SelectObject(hdc, bm2);
2373     HBITMAP old2 = SelectObject(screenDC, bm3);
2374     SelectObject(hdc, old1);
2375     SelectObject(screenDC, old2);
2376
2377     ok(bm == bm1 && bm == bm4 && bm == bm5 && bm == curObj1 && bm == old1,
2378        "0: %p, 1: %p, 4: %p, 5: %p, curObj1 %p, old1 %p\n",
2379        bm, bm1, bm4, bm5, curObj1, old1);
2380     ok(bm != bm2 && bm != bm3, "0: %p, 2: %p, 3: %p\n", bm, bm2, bm3);
2381 todo_wine
2382     ok(bm != curObj2, "0: %p, curObj2 %p\n", bm, curObj2);
2383     ok(old2 == 0, "old2 %p\n", old2);
2384
2385     test_mono_1x1_bmp(bm);
2386     test_mono_1x1_bmp(bm1);
2387     test_mono_1x1_bmp(bm2);
2388     test_mono_1x1_bmp(bm3);
2389     test_mono_1x1_bmp(bm4);
2390     test_mono_1x1_bmp(bm5);
2391     test_mono_1x1_bmp(old1);
2392     test_mono_1x1_bmp(curObj1);
2393
2394     DeleteObject(bm);
2395     DeleteObject(bm1);
2396     DeleteObject(bm2);
2397     DeleteObject(bm3);
2398     DeleteObject(bm4);
2399     DeleteObject(bm5);
2400
2401     DeleteDC(hdc);
2402     ReleaseDC(0, screenDC);
2403
2404     /* show that Windows ignores the provided bm.bmWidthBytes */
2405     bmp.bmType = 0;
2406     bmp.bmWidth = 1;
2407     bmp.bmHeight = 1;
2408     bmp.bmWidthBytes = 28;
2409     bmp.bmPlanes = 1;
2410     bmp.bmBitsPixel = 1;
2411     bmp.bmBits = NULL;
2412     bm = CreateBitmapIndirect(&bmp);
2413     ok(bm != 0, "CreateBitmapIndirect error %u\n", GetLastError());
2414     test_mono_1x1_bmp(bm);
2415     DeleteObject(bm);
2416
2417     /* Test how the bmBitsPixel field is treated */
2418     for(i = 1; i <= 33; i++) {
2419         bmp.bmType = 0;
2420         bmp.bmWidth = 1;
2421         bmp.bmHeight = 1;
2422         bmp.bmWidthBytes = 28;
2423         bmp.bmPlanes = 1;
2424         bmp.bmBitsPixel = i;
2425         bmp.bmBits = NULL;
2426         SetLastError(0xdeadbeef);
2427         bm = CreateBitmapIndirect(&bmp);
2428         if(i > 32) {
2429             DWORD error = GetLastError();
2430             ok(bm == 0, "CreateBitmapIndirect for %d bpp succeeded\n", i);
2431             ok(error == ERROR_INVALID_PARAMETER, "Got error %d, expected ERROR_INVALID_PARAMETER\n", error);
2432             DeleteObject(bm);
2433             continue;
2434         }
2435         ok(bm != 0, "CreateBitmapIndirect error %u\n", GetLastError());
2436         GetObject(bm, sizeof(bmp), &bmp);
2437         if(i == 1) {
2438             expect = 1;
2439         } else if(i <= 4) {
2440             expect = 4;
2441         } else if(i <= 8) {
2442             expect = 8;
2443         } else if(i <= 16) {
2444             expect = 16;
2445         } else if(i <= 24) {
2446             expect = 24;
2447         } else if(i <= 32) {
2448             expect = 32;
2449         }
2450         ok(bmp.bmBitsPixel == expect, "CreateBitmapIndirect for a %d bpp bitmap created a %d bpp bitmap, expected %d\n",
2451            i, bmp.bmBitsPixel, expect);
2452         DeleteObject(bm);
2453     }
2454 }
2455
2456 static void test_bitmapinfoheadersize(void)
2457 {
2458     HBITMAP hdib;
2459     BITMAPINFO bmi;
2460     BITMAPCOREINFO bci;
2461     HDC hdc = GetDC(0);
2462
2463     memset(&bmi, 0, sizeof(BITMAPINFO));
2464     bmi.bmiHeader.biHeight = 100;
2465     bmi.bmiHeader.biWidth = 512;
2466     bmi.bmiHeader.biBitCount = 24;
2467     bmi.bmiHeader.biPlanes = 1;
2468
2469     bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER) - 1;
2470
2471     hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
2472     ok(hdib == NULL, "CreateDIBSection succeeded\n");
2473
2474     bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2475
2476     SetLastError(0xdeadbeef);
2477     hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
2478     ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
2479     DeleteObject(hdib);
2480
2481     bmi.bmiHeader.biSize++;
2482
2483     SetLastError(0xdeadbeef);
2484     hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
2485     ok(hdib != NULL ||
2486        broken(!hdib), /* Win98, WinMe */
2487        "CreateDIBSection error %d\n", GetLastError());
2488     DeleteObject(hdib);
2489
2490     bmi.bmiHeader.biSize = sizeof(BITMAPINFO);
2491
2492     SetLastError(0xdeadbeef);
2493     hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
2494     ok(hdib != NULL ||
2495        broken(!hdib), /* Win98, WinMe */
2496        "CreateDIBSection error %d\n", GetLastError());
2497     DeleteObject(hdib);
2498
2499     bmi.bmiHeader.biSize++;
2500
2501     SetLastError(0xdeadbeef);
2502     hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
2503     ok(hdib != NULL ||
2504        broken(!hdib), /* Win98, WinMe */
2505        "CreateDIBSection error %d\n", GetLastError());
2506     DeleteObject(hdib);
2507
2508     bmi.bmiHeader.biSize = sizeof(BITMAPV4HEADER);
2509
2510     SetLastError(0xdeadbeef);
2511     hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
2512     ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
2513     DeleteObject(hdib);
2514
2515     bmi.bmiHeader.biSize = sizeof(BITMAPV5HEADER);
2516
2517     SetLastError(0xdeadbeef);
2518     hdib = CreateDIBSection(hdc, &bmi, 0, NULL, NULL, 0);
2519     ok(hdib != NULL ||
2520        broken(!hdib), /* Win95 */
2521        "CreateDIBSection error %d\n", GetLastError());
2522     DeleteObject(hdib);
2523
2524     memset(&bci, 0, sizeof(BITMAPCOREINFO));
2525     bci.bmciHeader.bcHeight = 100;
2526     bci.bmciHeader.bcWidth = 512;
2527     bci.bmciHeader.bcBitCount = 24;
2528     bci.bmciHeader.bcPlanes = 1;
2529
2530     bci.bmciHeader.bcSize = sizeof(BITMAPCOREHEADER) - 1;
2531
2532     hdib = CreateDIBSection(hdc, (BITMAPINFO *)&bci, 0, NULL, NULL, 0);
2533     ok(hdib == NULL, "CreateDIBSection succeeded\n");
2534
2535     bci.bmciHeader.bcSize = sizeof(BITMAPCOREHEADER);
2536
2537     SetLastError(0xdeadbeef);
2538     hdib = CreateDIBSection(hdc, (BITMAPINFO *)&bci, 0, NULL, NULL, 0);
2539     ok(hdib != NULL, "CreateDIBSection error %d\n", GetLastError());
2540     DeleteObject(hdib);
2541
2542     bci.bmciHeader.bcSize++;
2543
2544     hdib = CreateDIBSection(hdc, (BITMAPINFO *)&bci, 0, NULL, NULL, 0);
2545     ok(hdib == NULL, "CreateDIBSection succeeded\n");
2546
2547     bci.bmciHeader.bcSize = sizeof(BITMAPCOREINFO);
2548
2549     hdib = CreateDIBSection(hdc, (BITMAPINFO *)&bci, 0, NULL, NULL, 0);
2550     ok(hdib == NULL, "CreateDIBSection succeeded\n");
2551
2552     ReleaseDC(0, hdc);
2553 }
2554
2555 static void test_get16dibits(void)
2556 {
2557     BYTE bits[4 * (16 / sizeof(BYTE))];
2558     HBITMAP hbmp;
2559     HDC screen_dc = GetDC(NULL);
2560     int ret;
2561     BITMAPINFO * info;
2562     int info_len = sizeof(BITMAPINFOHEADER) + 1024;
2563     BYTE *p;
2564     int overwritten_bytes = 0;
2565
2566     memset(bits, 0, sizeof(bits));
2567     hbmp = CreateBitmap(2, 2, 1, 16, bits);
2568     ok(hbmp != NULL, "CreateBitmap failed\n");
2569
2570     info  = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, info_len);
2571     assert(info);
2572
2573     memset(info, '!', info_len);
2574     memset(info, 0, sizeof(info->bmiHeader));
2575
2576     info->bmiHeader.biSize = sizeof(info->bmiHeader);
2577     info->bmiHeader.biWidth = 2;
2578     info->bmiHeader.biHeight = 2;
2579     info->bmiHeader.biPlanes = 1;
2580     info->bmiHeader.biCompression = BI_RGB;
2581
2582     ret = GetDIBits(screen_dc, hbmp, 0, 0, NULL, info, 0);
2583     ok(ret != 0, "GetDIBits failed got %d\n", ret);
2584
2585     for (p = ((BYTE *) info) + sizeof(info->bmiHeader); (p - ((BYTE *) info)) < info_len; p++)
2586         if (*p != '!')
2587             overwritten_bytes++;
2588     ok(overwritten_bytes == 0, "GetDIBits wrote past the buffer given\n");
2589
2590     HeapFree(GetProcessHeap(), 0, info);
2591     DeleteObject(hbmp);
2592     ReleaseDC(NULL, screen_dc);
2593 }
2594
2595 static BOOL compare_buffers_no_alpha(UINT32 *a, UINT32 *b, int length)
2596 {
2597     int i;
2598     for(i = 0; i < length; i++)
2599         if((a[i] & 0x00FFFFFF) != (b[i] & 0x00FFFFFF))
2600             return FALSE;
2601     return TRUE;
2602 }
2603
2604 static void check_BitBlt_pixel(HDC hdcDst, HDC hdcSrc, UINT32 *dstBuffer, UINT32 *srcBuffer,
2605                                DWORD dwRop, UINT32 expected, int line)
2606 {
2607     *srcBuffer = 0xFEDCBA98;
2608     *dstBuffer = 0x89ABCDEF;
2609     Rectangle(hdcSrc, 0, 0, 1, 1);  /* A null operation to ensure dibs are coerced to X11 */
2610     BitBlt(hdcDst, 0, 0, 1, 1, hdcSrc, 0, 0, dwRop);
2611     ok(expected == *dstBuffer,
2612         "BitBlt with dwRop %06X. Expected 0x%08X, got 0x%08X from line %d\n",
2613         dwRop, expected, *dstBuffer, line);
2614 }
2615
2616 static void test_BitBlt(void)
2617 {
2618     HBITMAP bmpDst, bmpSrc;
2619     HBITMAP oldDst, oldSrc;
2620     HDC hdcScreen, hdcDst, hdcSrc;
2621     UINT32 *dstBuffer, *srcBuffer;
2622     HBRUSH hBrush, hOldBrush;
2623     BITMAPINFO bitmapInfo;
2624
2625     memset(&bitmapInfo, 0, sizeof(BITMAPINFO));
2626     bitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2627     bitmapInfo.bmiHeader.biWidth = 1;
2628     bitmapInfo.bmiHeader.biHeight = 1;
2629     bitmapInfo.bmiHeader.biPlanes = 1;
2630     bitmapInfo.bmiHeader.biBitCount = 32;
2631     bitmapInfo.bmiHeader.biCompression = BI_RGB;
2632     bitmapInfo.bmiHeader.biSizeImage = sizeof(UINT32);
2633
2634     hdcScreen = CreateCompatibleDC(0);
2635     hdcDst = CreateCompatibleDC(hdcScreen);
2636     hdcSrc = CreateCompatibleDC(hdcDst);
2637
2638     /* Setup the destination dib section */
2639     bmpDst = CreateDIBSection(hdcScreen, &bitmapInfo, DIB_RGB_COLORS, (void**)&dstBuffer,
2640         NULL, 0);
2641     oldDst = SelectObject(hdcDst, bmpDst);
2642
2643     hBrush = CreateSolidBrush(0x012345678);
2644     hOldBrush = SelectObject(hdcDst, hBrush);
2645
2646     /* Setup the source dib section */
2647     bmpSrc = CreateDIBSection(hdcScreen, &bitmapInfo, DIB_RGB_COLORS, (void**)&srcBuffer,
2648         NULL, 0);
2649     oldSrc = SelectObject(hdcSrc, bmpSrc);
2650
2651     check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, SRCCOPY, 0xFEDCBA98, __LINE__);
2652     check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, SRCPAINT, 0xFFFFFFFF, __LINE__);
2653     check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, SRCAND, 0x88888888, __LINE__);
2654     check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, SRCINVERT, 0x77777777, __LINE__);
2655     check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, SRCERASE, 0x76543210, __LINE__);
2656     check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, NOTSRCCOPY, 0x01234567, __LINE__);
2657     check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, NOTSRCERASE, 0x00000000, __LINE__);
2658     check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, MERGECOPY, 0x00581210, __LINE__);
2659     check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, MERGEPAINT, 0x89ABCDEF, __LINE__);
2660     check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, PATCOPY, 0x00785634, __LINE__);
2661     check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, PATPAINT, 0x89FBDFFF, __LINE__);
2662     check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, PATINVERT, 0x89D39BDB, __LINE__);
2663     check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, DSTINVERT, 0x76543210, __LINE__);
2664     check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, BLACKNESS, 0x00000000, __LINE__);
2665     check_BitBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, WHITENESS, 0xFFFFFFFF, __LINE__);
2666
2667     /* Tidy up */
2668     SelectObject(hdcSrc, oldSrc);
2669     DeleteObject(bmpSrc);
2670     DeleteDC(hdcSrc);
2671
2672     SelectObject(hdcDst, hOldBrush);
2673     DeleteObject(hBrush);
2674     SelectObject(hdcDst, oldDst);
2675     DeleteObject(bmpDst);
2676     DeleteDC(hdcDst);
2677
2678
2679     DeleteDC(hdcScreen);
2680 }
2681
2682 static void check_StretchBlt_pixel(HDC hdcDst, HDC hdcSrc, UINT32 *dstBuffer, UINT32 *srcBuffer,
2683                                    DWORD dwRop, UINT32 expected, int line)
2684 {
2685     *srcBuffer = 0xFEDCBA98;
2686     *dstBuffer = 0x89ABCDEF;
2687     StretchBlt(hdcDst, 0, 0, 2, 1, hdcSrc, 0, 0, 1, 1, dwRop);
2688     ok(expected == *dstBuffer,
2689         "StretchBlt with dwRop %06X. Expected 0x%08X, got 0x%08X from line %d\n",
2690         dwRop, expected, *dstBuffer, line);
2691 }
2692
2693 static void check_StretchBlt_stretch(HDC hdcDst, HDC hdcSrc, UINT32 *dstBuffer, UINT32 *srcBuffer,
2694                                      int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest,
2695                                      int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc,
2696                                      UINT32 expected[4], UINT32 legacy_expected[4], int line)
2697 {
2698     memset(dstBuffer, 0, 16);
2699     StretchBlt(hdcDst, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
2700                hdcSrc, nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc, SRCCOPY);
2701     ok(memcmp(dstBuffer, expected, 16) == 0 ||
2702         broken(compare_buffers_no_alpha(dstBuffer, legacy_expected, 4)),
2703         "StretchBlt expected { %08X, %08X, %08X, %08X } got { %08X, %08X, %08X, %08X } "
2704         "stretching { %d, %d, %d, %d } to { %d, %d, %d, %d } from line %d\n",
2705         expected[0], expected[1], expected[2], expected[3],
2706         dstBuffer[0], dstBuffer[1], dstBuffer[2], dstBuffer[3],
2707         nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc,
2708         nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, line);
2709 }
2710
2711 static void test_StretchBlt(void)
2712 {
2713     HBITMAP bmpDst, bmpSrc;
2714     HBITMAP oldDst, oldSrc;
2715     HDC hdcScreen, hdcDst, hdcSrc;
2716     UINT32 *dstBuffer, *srcBuffer;
2717     HBRUSH hBrush, hOldBrush;
2718     BITMAPINFO biDst, biSrc;
2719     UINT32 expected[4], legacy_expected[4];
2720
2721     memset(&biDst, 0, sizeof(BITMAPINFO));
2722     biDst.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2723     biDst.bmiHeader.biWidth = 2;
2724     biDst.bmiHeader.biHeight = -2;
2725     biDst.bmiHeader.biPlanes = 1;
2726     biDst.bmiHeader.biBitCount = 32;
2727     biDst.bmiHeader.biCompression = BI_RGB;
2728     memcpy(&biSrc, &biDst, sizeof(BITMAPINFO));
2729
2730     hdcScreen = CreateCompatibleDC(0);
2731     hdcDst = CreateCompatibleDC(hdcScreen);
2732     hdcSrc = CreateCompatibleDC(hdcDst);
2733
2734     /* Pixel Tests */
2735     bmpDst = CreateDIBSection(hdcScreen, &biDst, DIB_RGB_COLORS, (void**)&dstBuffer,
2736         NULL, 0);
2737     oldDst = SelectObject(hdcDst, bmpDst);
2738
2739     bmpSrc = CreateDIBSection(hdcScreen, &biDst, DIB_RGB_COLORS, (void**)&srcBuffer,
2740         NULL, 0);
2741     oldSrc = SelectObject(hdcSrc, bmpSrc);
2742
2743     hBrush = CreateSolidBrush(0x012345678);
2744     hOldBrush = SelectObject(hdcDst, hBrush);
2745
2746     check_StretchBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, SRCCOPY, 0xFEDCBA98, __LINE__);
2747     check_StretchBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, SRCPAINT, 0xFFFFFFFF, __LINE__);
2748     check_StretchBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, SRCAND, 0x88888888, __LINE__);
2749     check_StretchBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, SRCINVERT, 0x77777777, __LINE__);
2750     check_StretchBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, SRCERASE, 0x76543210, __LINE__);
2751     check_StretchBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, NOTSRCCOPY, 0x01234567, __LINE__);
2752     check_StretchBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, NOTSRCERASE, 0x00000000, __LINE__);
2753     check_StretchBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, MERGECOPY, 0x00581210, __LINE__);
2754     check_StretchBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, MERGEPAINT, 0x89ABCDEF, __LINE__);
2755     check_StretchBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, PATCOPY, 0x00785634, __LINE__);
2756     check_StretchBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, PATPAINT, 0x89FBDFFF, __LINE__);
2757     check_StretchBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, PATINVERT, 0x89D39BDB, __LINE__);
2758     check_StretchBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, DSTINVERT, 0x76543210, __LINE__);
2759     check_StretchBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, BLACKNESS, 0x00000000, __LINE__);
2760     check_StretchBlt_pixel(hdcDst, hdcSrc, dstBuffer, srcBuffer, WHITENESS, 0xFFFFFFFF, __LINE__);
2761
2762     SelectObject(hdcDst, hOldBrush);
2763     DeleteObject(hBrush);
2764
2765     /* Top-down to top-down tests */
2766     srcBuffer[0] = 0xCAFED00D, srcBuffer[1] = 0xFEEDFACE;
2767     srcBuffer[2] = 0xFEDCBA98, srcBuffer[3] = 0x76543210;
2768
2769     expected[0] = 0xCAFED00D, expected[1] = 0xFEEDFACE;
2770     expected[2] = 0xFEDCBA98, expected[3] = 0x76543210;
2771     check_StretchBlt_stretch(hdcDst, hdcSrc, dstBuffer, srcBuffer,
2772                              0, 0, 2, 2, 0, 0, 2, 2, expected, expected, __LINE__);
2773
2774     expected[0] = 0xCAFED00D, expected[1] = 0x00000000;
2775     expected[2] = 0x00000000, expected[3] = 0x00000000;
2776     check_StretchBlt_stretch(hdcDst, hdcSrc, dstBuffer, srcBuffer,
2777                              0, 0, 1, 1, 0, 0, 1, 1, expected, expected, __LINE__);
2778
2779     expected[0] = 0xCAFED00D, expected[1] = 0xCAFED00D;
2780     expected[2] = 0xCAFED00D, expected[3] = 0xCAFED00D;
2781     check_StretchBlt_stretch(hdcDst, hdcSrc, dstBuffer, srcBuffer,
2782                              0, 0, 2, 2, 0, 0, 1, 1, expected, expected, __LINE__);
2783
2784     expected[0] = 0xCAFED00D, expected[1] = 0x00000000;
2785     expected[2] = 0x00000000, expected[3] = 0x00000000;
2786     check_StretchBlt_stretch(hdcDst, hdcSrc, dstBuffer, srcBuffer,
2787                              0, 0, 1, 1, 0, 0, 2, 2, expected, expected, __LINE__);
2788
2789     expected[0] = 0x76543210, expected[1] = 0xFEDCBA98;
2790     expected[2] = 0xFEEDFACE, expected[3] = 0xCAFED00D;
2791     check_StretchBlt_stretch(hdcDst, hdcSrc, dstBuffer, srcBuffer,
2792                              0, 0, 2, 2, 1, 1, -2, -2, expected, expected, __LINE__);
2793
2794     expected[0] = 0x76543210, expected[1] = 0xFEDCBA98;
2795     expected[2] = 0xFEEDFACE, expected[3] = 0xCAFED00D;
2796     check_StretchBlt_stretch(hdcDst, hdcSrc, dstBuffer, srcBuffer,
2797                              1, 1, -2, -2, 0, 0, 2, 2, expected, expected, __LINE__);
2798
2799     /* This result seems broken. One might expect the following result:
2800      * 0xCAFED00D 0xFEEDFACE
2801      * 0xFEDCBA98 0x76543210
2802      */
2803     expected[0] = 0xCAFED00D, expected[1] = 0x00000000;
2804     expected[2] = 0xFEDCBA98, expected[3] = 0x76543210;
2805     legacy_expected[0] = 0xCAFED00D, legacy_expected[1] = 0x00000000;
2806     legacy_expected[2] = 0x00000000, legacy_expected[3] = 0x00000000;
2807     todo_wine check_StretchBlt_stretch(hdcDst, hdcSrc, dstBuffer, srcBuffer,
2808                                        1, 1, -2, -2, 1, 1, -2, -2, expected,
2809                                        legacy_expected, __LINE__);
2810
2811     expected[0] = 0x00000000, expected[1] = 0x00000000;
2812     expected[2] = 0x00000000, expected[3] = 0xCAFED00D;
2813     check_StretchBlt_stretch(hdcDst, hdcSrc, dstBuffer, srcBuffer,
2814                              1, 1, 2, 2, 0, 0, 2, 2, expected, expected, __LINE__);
2815
2816     SelectObject(hdcDst, oldDst);
2817     DeleteObject(bmpDst);
2818
2819     /* Top-down to bottom-up tests */
2820     biDst.bmiHeader.biHeight = 2;
2821     bmpDst = CreateDIBSection(hdcScreen, &biDst, DIB_RGB_COLORS, (void**)&dstBuffer,
2822         NULL, 0);
2823     oldDst = SelectObject(hdcDst, bmpDst);
2824
2825     expected[0] = 0xFEDCBA98, expected[1] = 0x76543210;
2826     expected[2] = 0xCAFED00D, expected[3] = 0xFEEDFACE;
2827     check_StretchBlt_stretch(hdcDst, hdcSrc, dstBuffer, srcBuffer,
2828                              0, 0, 2, 2, 0, 0, 2, 2, expected, expected, __LINE__);
2829
2830     expected[0] = 0xFEEDFACE, expected[1] = 0xCAFED00D;
2831     expected[2] = 0x76543210, expected[3] = 0xFEDCBA98;
2832     check_StretchBlt_stretch(hdcDst, hdcSrc, dstBuffer, srcBuffer,
2833                              0, 0, 2, 2, 1, 1, -2, -2, expected, expected, __LINE__);
2834
2835     SelectObject(hdcSrc, oldSrc);
2836     DeleteObject(bmpSrc);
2837
2838     /* Bottom-up to bottom-up tests */
2839     biSrc.bmiHeader.biHeight = 2;
2840     bmpSrc = CreateDIBSection(hdcScreen, &biSrc, DIB_RGB_COLORS, (void**)&srcBuffer,
2841         NULL, 0);
2842     srcBuffer[0] = 0xCAFED00D, srcBuffer[1] = 0xFEEDFACE;
2843     srcBuffer[2] = 0xFEDCBA98, srcBuffer[3] = 0x76543210;
2844     oldSrc = SelectObject(hdcSrc, bmpSrc);
2845
2846     expected[0] = 0xCAFED00D, expected[1] = 0xFEEDFACE;
2847     expected[2] = 0xFEDCBA98, expected[3] = 0x76543210;
2848     check_StretchBlt_stretch(hdcDst, hdcSrc, dstBuffer, srcBuffer,
2849                              0, 0, 2, 2, 0, 0, 2, 2, expected, expected, __LINE__);
2850
2851     expected[0] = 0x76543210, expected[1] = 0xFEDCBA98;
2852     expected[2] = 0xFEEDFACE, expected[3] = 0xCAFED00D;
2853     check_StretchBlt_stretch(hdcDst, hdcSrc, dstBuffer, srcBuffer,
2854                              0, 0, 2, 2, 1, 1, -2, -2, expected, expected, __LINE__);
2855
2856     SelectObject(hdcDst, oldDst);
2857     DeleteObject(bmpDst);
2858
2859     /* Bottom-up to top-down tests */
2860     biDst.bmiHeader.biHeight = -2;
2861     bmpDst = CreateDIBSection(hdcScreen, &biDst, DIB_RGB_COLORS, (void**)&dstBuffer,
2862         NULL, 0);
2863     oldDst = SelectObject(hdcDst, bmpDst);
2864
2865     expected[0] = 0xFEDCBA98, expected[1] = 0x76543210;
2866     expected[2] = 0xCAFED00D, expected[3] = 0xFEEDFACE;
2867     check_StretchBlt_stretch(hdcDst, hdcSrc, dstBuffer, srcBuffer,
2868                              0, 0, 2, 2, 0, 0, 2, 2, expected, expected, __LINE__);
2869
2870     expected[0] = 0xFEEDFACE, expected[1] = 0xCAFED00D;
2871     expected[2] = 0x76543210, expected[3] = 0xFEDCBA98;
2872     check_StretchBlt_stretch(hdcDst, hdcSrc, dstBuffer, srcBuffer,
2873                              0, 0, 2, 2, 1, 1, -2, -2, expected, expected, __LINE__);
2874
2875     /* Tidy up */
2876     SelectObject(hdcSrc, oldSrc);
2877     DeleteObject(bmpSrc);
2878     DeleteDC(hdcSrc);
2879
2880     SelectObject(hdcDst, oldDst);
2881     DeleteObject(bmpDst);
2882     DeleteDC(hdcDst);
2883
2884     DeleteDC(hdcScreen);
2885 }
2886
2887 static void check_StretchDIBits_pixel(HDC hdcDst, UINT32 *dstBuffer, UINT32 *srcBuffer,
2888                                       DWORD dwRop, UINT32 expected, int line)
2889 {
2890     const UINT32 buffer[2] = { 0xFEDCBA98, 0 };
2891     BITMAPINFO bitmapInfo;
2892
2893     memset(&bitmapInfo, 0, sizeof(BITMAPINFO));
2894     bitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2895     bitmapInfo.bmiHeader.biWidth = 2;
2896     bitmapInfo.bmiHeader.biHeight = 1;
2897     bitmapInfo.bmiHeader.biPlanes = 1;
2898     bitmapInfo.bmiHeader.biBitCount = 32;
2899     bitmapInfo.bmiHeader.biCompression = BI_RGB;
2900     bitmapInfo.bmiHeader.biSizeImage = sizeof(buffer);
2901
2902     *dstBuffer = 0x89ABCDEF;
2903
2904     StretchDIBits(hdcDst, 0, 0, 2, 1, 0, 0, 1, 1, &buffer, &bitmapInfo, DIB_RGB_COLORS, dwRop);
2905     ok(expected == *dstBuffer,
2906         "StretchDIBits with dwRop %06X. Expected 0x%08X, got 0x%08X from line %d\n",
2907         dwRop, expected, *dstBuffer, line);
2908 }
2909
2910 static void check_StretchDIBits_stretch(HDC hdcDst, UINT32 *dstBuffer, UINT32 *srcBuffer,
2911                                         int nXOriginDest, int nYOriginDest, int nWidthDest, int nHeightDest,
2912                                         int nXOriginSrc, int nYOriginSrc, int nWidthSrc, int nHeightSrc,
2913                                         UINT32 expected[4], UINT32 legacy_expected[4], int line)
2914 {
2915     BITMAPINFO bitmapInfo;
2916
2917     memset(&bitmapInfo, 0, sizeof(BITMAPINFO));
2918     bitmapInfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2919     bitmapInfo.bmiHeader.biWidth = 2;
2920     bitmapInfo.bmiHeader.biHeight = -2;
2921     bitmapInfo.bmiHeader.biPlanes = 1;
2922     bitmapInfo.bmiHeader.biBitCount = 32;
2923     bitmapInfo.bmiHeader.biCompression = BI_RGB;
2924
2925     memset(dstBuffer, 0, 16);
2926     StretchDIBits(hdcDst, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest,
2927                   nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc,
2928                   srcBuffer, &bitmapInfo, DIB_RGB_COLORS, SRCCOPY);
2929     ok(memcmp(dstBuffer, expected, 16) == 0,
2930         "StretchDIBits expected { %08X, %08X, %08X, %08X } got { %08X, %08X, %08X, %08X } "
2931         "stretching { %d, %d, %d, %d } to { %d, %d, %d, %d } from line %d\n",
2932         expected[0], expected[1], expected[2], expected[3],
2933         dstBuffer[0], dstBuffer[1], dstBuffer[2], dstBuffer[3],
2934         nXOriginSrc, nYOriginSrc, nWidthSrc, nHeightSrc,
2935         nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, line);
2936 }
2937
2938 static void test_StretchDIBits(void)
2939 {
2940     HBITMAP bmpDst;
2941     HBITMAP oldDst;
2942     HDC hdcScreen, hdcDst;
2943     UINT32 *dstBuffer, srcBuffer[4];
2944     HBRUSH hBrush, hOldBrush;
2945     BITMAPINFO biDst;
2946     UINT32 expected[4], legacy_expected[4];
2947
2948     memset(&biDst, 0, sizeof(BITMAPINFO));
2949     biDst.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
2950     biDst.bmiHeader.biWidth = 2;
2951     biDst.bmiHeader.biHeight = -2;
2952     biDst.bmiHeader.biPlanes = 1;
2953     biDst.bmiHeader.biBitCount = 32;
2954     biDst.bmiHeader.biCompression = BI_RGB;
2955
2956     hdcScreen = CreateCompatibleDC(0);
2957     hdcDst = CreateCompatibleDC(hdcScreen);
2958
2959     /* Pixel Tests */
2960     bmpDst = CreateDIBSection(hdcScreen, &biDst, DIB_RGB_COLORS, (void**)&dstBuffer,
2961         NULL, 0);
2962     oldDst = SelectObject(hdcDst, bmpDst);
2963
2964     hBrush = CreateSolidBrush(0x012345678);
2965     hOldBrush = SelectObject(hdcDst, hBrush);
2966
2967     check_StretchDIBits_pixel(hdcDst, dstBuffer, srcBuffer, SRCCOPY, 0xFEDCBA98, __LINE__);
2968     check_StretchDIBits_pixel(hdcDst, dstBuffer, srcBuffer, SRCPAINT, 0xFFFFFFFF, __LINE__);
2969     check_StretchDIBits_pixel(hdcDst, dstBuffer, srcBuffer, SRCAND, 0x88888888, __LINE__);
2970     check_StretchDIBits_pixel(hdcDst, dstBuffer, srcBuffer, SRCINVERT, 0x77777777, __LINE__);
2971     check_StretchDIBits_pixel(hdcDst, dstBuffer, srcBuffer, SRCERASE, 0x76543210, __LINE__);
2972     check_StretchDIBits_pixel(hdcDst, dstBuffer, srcBuffer, NOTSRCCOPY, 0x01234567, __LINE__);
2973     check_StretchDIBits_pixel(hdcDst, dstBuffer, srcBuffer, NOTSRCERASE, 0x00000000, __LINE__);
2974     check_StretchDIBits_pixel(hdcDst, dstBuffer, srcBuffer, MERGECOPY, 0x00581210, __LINE__);
2975     check_StretchDIBits_pixel(hdcDst, dstBuffer, srcBuffer, MERGEPAINT, 0x89ABCDEF, __LINE__);
2976     check_StretchDIBits_pixel(hdcDst, dstBuffer, srcBuffer, PATCOPY, 0x00785634, __LINE__);
2977     check_StretchDIBits_pixel(hdcDst, dstBuffer, srcBuffer, PATPAINT, 0x89FBDFFF, __LINE__);
2978     check_StretchDIBits_pixel(hdcDst, dstBuffer, srcBuffer, PATINVERT, 0x89D39BDB, __LINE__);
2979     check_StretchDIBits_pixel(hdcDst, dstBuffer, srcBuffer, DSTINVERT, 0x76543210, __LINE__);
2980     check_StretchDIBits_pixel(hdcDst, dstBuffer, srcBuffer, BLACKNESS, 0x00000000, __LINE__);
2981     check_StretchDIBits_pixel(hdcDst, dstBuffer, srcBuffer, WHITENESS, 0xFFFFFFFF, __LINE__);
2982
2983     SelectObject(hdcDst, hOldBrush);
2984     DeleteObject(hBrush);
2985
2986     /* Top-down destination tests */
2987     srcBuffer[0] = 0xCAFED00D, srcBuffer[1] = 0xFEEDFACE;
2988     srcBuffer[2] = 0xFEDCBA98, srcBuffer[3] = 0x76543210;
2989
2990     expected[0] = 0xCAFED00D, expected[1] = 0xFEEDFACE;
2991     expected[2] = 0xFEDCBA98, expected[3] = 0x76543210;
2992     check_StretchDIBits_stretch(hdcDst, dstBuffer, srcBuffer,
2993                                 0, 0, 2, 2, 0, 0, 2, 2, expected, expected, __LINE__);
2994
2995     expected[0] = 0xCAFED00D, expected[1] = 0x00000000;
2996     expected[2] = 0x00000000, expected[3] = 0x00000000;
2997     legacy_expected[0] = 0xFEDCBA98, legacy_expected[1] = 0x00000000;
2998     legacy_expected[2] = 0x00000000, legacy_expected[3] = 0x00000000;
2999     check_StretchDIBits_stretch(hdcDst, dstBuffer, srcBuffer,
3000                                 0, 0, 1, 1, 0, 0, 1, 1, expected, legacy_expected, __LINE__);
3001
3002     expected[0] = 0xFEDCBA98, expected[1] = 0xFEDCBA98;
3003     expected[2] = 0xFEDCBA98, expected[3] = 0xFEDCBA98;
3004     check_StretchDIBits_stretch(hdcDst, dstBuffer, srcBuffer,
3005                                 0, 0, 2, 2, 0, 0, 1, 1, expected, expected, __LINE__);
3006
3007     expected[0] = 0x42441000, expected[1] = 0x00000000;
3008     expected[2] = 0x00000000, expected[3] = 0x00000000;
3009     legacy_expected[0] = 0x00543210, legacy_expected[1] = 0x00000000;
3010     legacy_expected[2] = 0x00000000, legacy_expected[3] = 0x00000000;
3011     todo_wine check_StretchDIBits_stretch(hdcDst, dstBuffer, srcBuffer,
3012                                 0, 0, 1, 1, 0, 0, 2, 2, expected, legacy_expected, __LINE__);
3013
3014     expected[0] = 0x00000000, expected[1] = 0x00000000;
3015     expected[2] = 0x00000000, expected[3] = 0x00000000;
3016     check_StretchDIBits_stretch(hdcDst, dstBuffer, srcBuffer,
3017                                 0, 0, 2, 2, 1, 1, -2, -2, expected, expected, __LINE__);
3018
3019     expected[0] = 0x00000000, expected[1] = 0x00000000;
3020     expected[2] = 0x00000000, expected[3] = 0x00000000;
3021     check_StretchDIBits_stretch(hdcDst, dstBuffer, srcBuffer,
3022                                 0, 0, 2, 2, 1, 1, -2, -2, expected, expected, __LINE__);
3023
3024     expected[0] = 0x00000000, expected[1] = 0x00000000;
3025     expected[2] = 0x00000000, expected[3] = 0x00000000;
3026     check_StretchDIBits_stretch(hdcDst, dstBuffer, srcBuffer,
3027                                 1, 1, -2, -2, 1, 1, -2, -2, expected, expected, __LINE__);
3028
3029     expected[0] = 0x00000000, expected[1] = 0x00000000;
3030     expected[2] = 0x00000000, expected[3] = 0xCAFED00D;
3031     check_StretchDIBits_stretch(hdcDst, dstBuffer, srcBuffer,
3032                                 1, 1, 2, 2, 0, 0, 2, 2, expected, expected, __LINE__);
3033
3034     SelectObject(hdcDst, oldDst);
3035     DeleteObject(bmpDst);
3036
3037     /* Bottom up destination tests */
3038     biDst.bmiHeader.biHeight = 2;
3039     bmpDst = CreateDIBSection(hdcScreen, &biDst, DIB_RGB_COLORS, (void**)&dstBuffer,
3040         NULL, 0);
3041     oldDst = SelectObject(hdcDst, bmpDst);
3042
3043     expected[0] = 0xFEDCBA98, expected[1] = 0x76543210;
3044     expected[2] = 0xCAFED00D, expected[3] = 0xFEEDFACE;
3045     check_StretchDIBits_stretch(hdcDst, dstBuffer, srcBuffer,
3046                                 0, 0, 2, 2, 0, 0, 2, 2, expected, expected, __LINE__);
3047
3048     /* Tidy up */
3049     SelectObject(hdcDst, oldDst);
3050     DeleteObject(bmpDst);
3051     DeleteDC(hdcDst);
3052
3053     DeleteDC(hdcScreen);
3054 }
3055
3056 static void test_GdiAlphaBlend(void)
3057 {
3058     /* test out-of-bound parameters for GdiAlphaBlend */
3059     HDC hdcNull;
3060
3061     HDC hdcDst;
3062     HBITMAP bmpDst;
3063     HBITMAP oldDst;
3064
3065     BITMAPINFO bmi;
3066     HDC hdcSrc;
3067     HBITMAP bmpSrc;
3068     HBITMAP oldSrc;
3069     LPVOID bits;
3070
3071     BLENDFUNCTION blend;
3072
3073     if (!pGdiAlphaBlend)
3074     {
3075         win_skip("GdiAlphaBlend() is not implemented\n");
3076         return;
3077     }
3078
3079     hdcNull = GetDC(NULL);
3080     hdcDst = CreateCompatibleDC(hdcNull);
3081     bmpDst = CreateCompatibleBitmap(hdcNull, 100, 100);
3082     hdcSrc = CreateCompatibleDC(hdcNull);
3083
3084     memset(&bmi, 0, sizeof(bmi));  /* as of Wine 0.9.44 we require the src to be a DIB section */
3085     bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
3086     bmi.bmiHeader.biHeight = 20;
3087     bmi.bmiHeader.biWidth = 20;
3088     bmi.bmiHeader.biBitCount = 32;
3089     bmi.bmiHeader.biPlanes = 1;
3090     bmi.bmiHeader.biCompression = BI_RGB;
3091     bmpSrc = CreateDIBSection(hdcDst, &bmi, DIB_RGB_COLORS, &bits, NULL, 0);
3092     ok(bmpSrc != NULL, "Couldn't create source bitmap\n");
3093
3094     oldDst = SelectObject(hdcDst, bmpDst);
3095     oldSrc = SelectObject(hdcSrc, bmpSrc);
3096
3097     blend.BlendOp = AC_SRC_OVER;
3098     blend.BlendFlags = 0;
3099     blend.SourceConstantAlpha = 128;
3100     blend.AlphaFormat = 0;
3101
3102     expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, 0, 0, 20, 20, blend), TRUE, BOOL, "%d");
3103     SetLastError(0xdeadbeef);
3104     expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, -1, 0, 10, 10, blend), FALSE, BOOL, "%d");
3105     expect_eq(GetLastError(), ERROR_INVALID_PARAMETER, int, "%d");
3106     expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, 0, -1, 10, 10, blend), FALSE, BOOL, "%d");
3107     expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, 15, 0, 10, 10, blend), FALSE, BOOL, "%d");
3108     expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, 10, 10, -2, 3, blend), FALSE, BOOL, "%d");
3109     expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, 10, 10, -2, 3, blend), FALSE, BOOL, "%d");
3110
3111     SetWindowOrgEx(hdcSrc, -10, -10, NULL);
3112     expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, -1, 0, 10, 10, blend), TRUE, BOOL, "%d");
3113     expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, 0, -1, 10, 10, blend), TRUE, BOOL, "%d");
3114     SetMapMode(hdcSrc, MM_ANISOTROPIC);
3115     ScaleWindowExtEx(hdcSrc, 10, 1, 10, 1, NULL);
3116     expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, -1, 0, 30, 30, blend), TRUE, BOOL, "%d");
3117     expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, hdcSrc, 0, -1, 30, 30, blend), TRUE, BOOL, "%d");
3118
3119     SetLastError(0xdeadbeef);
3120     expect_eq(pGdiAlphaBlend(hdcDst, 0, 0, 20, 20, NULL, 0, 0, 20, 20, blend), FALSE, BOOL, "%d");
3121     expect_eq(GetLastError(), 0xdeadbeef, int, "%d");
3122
3123     SelectObject(hdcDst, oldDst);
3124     SelectObject(hdcSrc, oldSrc);
3125     DeleteObject(bmpSrc);
3126     DeleteObject(bmpDst);
3127     DeleteDC(hdcDst);
3128     DeleteDC(hdcSrc);
3129
3130     ReleaseDC(NULL, hdcNull);
3131
3132 }
3133
3134 static void test_clipping(void)
3135 {
3136     HBITMAP bmpDst;
3137     HBITMAP bmpSrc;
3138     HRGN hRgn;
3139     LPVOID bits;
3140     BOOL result;
3141
3142     HDC hdcDst = CreateCompatibleDC( NULL );
3143     HDC hdcSrc = CreateCompatibleDC( NULL );
3144
3145     BITMAPINFO bmpinfo={{0}};
3146     bmpinfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
3147     bmpinfo.bmiHeader.biWidth = 100;
3148     bmpinfo.bmiHeader.biHeight = 100;
3149     bmpinfo.bmiHeader.biPlanes = 1;
3150     bmpinfo.bmiHeader.biBitCount = GetDeviceCaps( hdcDst, BITSPIXEL );
3151     bmpinfo.bmiHeader.biCompression = BI_RGB;
3152
3153     bmpDst = CreateDIBSection( hdcDst, &bmpinfo, DIB_RGB_COLORS, &bits, NULL, 0 );
3154     ok(bmpDst != NULL, "Couldn't create destination bitmap\n");
3155     SelectObject( hdcDst, bmpDst );
3156
3157     bmpSrc = CreateDIBSection( hdcSrc, &bmpinfo, DIB_RGB_COLORS, &bits, NULL, 0 );
3158     ok(bmpSrc != NULL, "Couldn't create source bitmap\n");
3159     SelectObject( hdcSrc, bmpSrc );
3160
3161     result = BitBlt( hdcDst, 0, 0, 100, 100, hdcSrc, 100, 100, SRCCOPY );
3162     ok(result, "BitBlt failed\n");
3163
3164     hRgn = CreateRectRgn( 0,0,0,0 );
3165     SelectClipRgn( hdcDst, hRgn );
3166
3167     result = BitBlt( hdcDst, 0, 0, 100, 100, hdcSrc, 0, 0, SRCCOPY );
3168     ok(result, "BitBlt failed\n");
3169
3170     DeleteObject( bmpDst );
3171     DeleteObject( bmpSrc );
3172     DeleteObject( hRgn );
3173     DeleteDC( hdcDst );
3174     DeleteDC( hdcSrc );
3175 }
3176
3177 static void test_32bit_bitmap_blt(void)
3178 {
3179     BITMAPINFO biDst;
3180     HBITMAP bmpSrc, bmpDst;
3181     HBITMAP oldSrc, oldDst;
3182     HDC hdcSrc, hdcDst, hdcScreen;
3183     UINT32 *dstBuffer;
3184     DWORD colorSrc = 0x11223344;
3185
3186     memset(&biDst, 0, sizeof(BITMAPINFO));
3187     biDst.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
3188     biDst.bmiHeader.biWidth = 2;
3189     biDst.bmiHeader.biHeight = -2;
3190     biDst.bmiHeader.biPlanes = 1;
3191     biDst.bmiHeader.biBitCount = 32;
3192     biDst.bmiHeader.biCompression = BI_RGB;
3193
3194     hdcScreen = CreateCompatibleDC(0);
3195     if(GetDeviceCaps(hdcScreen, BITSPIXEL) != 32)
3196     {
3197         DeleteDC(hdcScreen);
3198         trace("Skipping 32-bit DDB test\n");
3199         return;
3200     }
3201
3202     hdcSrc = CreateCompatibleDC(hdcScreen);
3203     bmpSrc = CreateBitmap(1, 1, 1, 32, &colorSrc);
3204     oldSrc = SelectObject(hdcSrc, bmpSrc);
3205
3206     hdcDst = CreateCompatibleDC(hdcScreen);
3207     bmpDst = CreateDIBSection(hdcDst, &biDst, DIB_RGB_COLORS, (void**)&dstBuffer, NULL, 0);
3208     oldDst = SelectObject(hdcDst, bmpDst);
3209
3210     StretchBlt(hdcDst, 0, 0, 1, 1, hdcSrc, 0, 0, 1, 1, SRCCOPY);
3211     ok(dstBuffer[0] == colorSrc, "Expected color=%x, received color=%x\n", colorSrc, dstBuffer[0]);
3212
3213     /* Tidy up */
3214     SelectObject(hdcDst, oldDst);
3215     DeleteObject(bmpDst);
3216     DeleteDC(hdcDst);
3217
3218     SelectObject(hdcSrc, oldSrc);
3219     DeleteObject(bmpSrc);
3220     DeleteDC(hdcSrc);
3221
3222     DeleteDC(hdcScreen);
3223 }
3224
3225 /*
3226  * Used by test_GetDIBits_top_down to create the bitmap to test against.
3227  */
3228 static void setup_picture(char *picture, int bpp)
3229 {
3230     int i;
3231
3232     switch(bpp)
3233     {
3234         case 16:
3235         case 32:
3236             /*Set the first byte in each pixel to the index of that pixel.*/
3237             for (i = 0; i < 4; i++)
3238                 picture[i * (bpp / 8)] = i;
3239             break;
3240         case 24:
3241             picture[0] = 0;
3242             picture[3] = 1;
3243             /*Each scanline in a bitmap must be a multiple of 4 bytes long.*/
3244             picture[8] = 2;
3245             picture[11] = 3;
3246             break;
3247     }
3248 }
3249
3250 static void test_GetDIBits_top_down(int bpp)
3251 {
3252     BITMAPINFO bi;
3253     HBITMAP bmptb, bmpbt;
3254     HDC hdc;
3255     int pictureOut[4];
3256     int *picture;
3257     int statusCode;
3258
3259     bi.bmiHeader.biSize=sizeof(bi.bmiHeader);
3260     bi.bmiHeader.biWidth=2;
3261     bi.bmiHeader.biHeight=2;
3262     bi.bmiHeader.biPlanes=1;
3263     bi.bmiHeader.biBitCount=bpp;
3264     bi.bmiHeader.biCompression=BI_RGB;
3265
3266     /*Get the device context for the screen.*/
3267     hdc = GetDC(NULL);
3268     ok(hdc != NULL, "Could not get a handle to a device context.\n");
3269
3270     /*Create the bottom to top image (image's bottom scan line is at the top in memory).*/
3271     bmpbt = CreateDIBSection(hdc, &bi, DIB_RGB_COLORS, (void**)&picture, NULL, 0);
3272     ok(bmpbt != NULL, "Could not create a DIB section.\n");
3273     /*Now that we have a pointer to the pixels, we write to them.*/
3274     setup_picture((char*)picture, bpp);
3275     /*Create the top to bottom image (images' bottom scan line is at the bottom in memory).*/
3276     bi.bmiHeader.biHeight=-2; /*We specify that we want a top to bottom image by specifying a negative height.*/
3277     bmptb = CreateDIBSection(hdc, &bi, DIB_RGB_COLORS, (void**)&picture, NULL, 0);
3278     ok(bmptb != NULL, "Could not create a DIB section.\n");
3279     /*Write to this top to bottom bitmap.*/
3280     setup_picture((char*)picture, bpp);
3281
3282     bi.bmiHeader.biWidth = 1;
3283
3284     bi.bmiHeader.biHeight = 2;
3285     statusCode = GetDIBits(hdc, bmpbt, 0, 1, pictureOut, &bi, DIB_RGB_COLORS);
3286     ok(statusCode, "Failed to call GetDIBits. Status code: %d.\n", statusCode);
3287     /*Check the first byte of the pixel.*/
3288     ok((char)pictureOut[0] == 0, "Bottom-up -> bottom-up: first pixel should be 0 but was %d.\n", (char)pictureOut[0]);
3289     statusCode = GetDIBits(hdc, bmptb, 0, 1, pictureOut, &bi, DIB_RGB_COLORS);
3290     ok(statusCode, "Failed to call GetDIBits. Status code: %d.\n", statusCode);
3291     ok((char)pictureOut[0] == 2, "Top-down -> bottom-up: first pixel should be 2 but was %d.\n", (char)pictureOut[0]);
3292     /*Check second scanline.*/
3293     statusCode = GetDIBits(hdc, bmptb, 1, 1, pictureOut, &bi, DIB_RGB_COLORS);
3294     ok(statusCode, "Failed to call GetDIBits. Status code: %d.\n", statusCode);
3295     ok((char)pictureOut[0] == 0, "Top-down -> bottom-up: first pixel should be 0 but was %d.\n", (char)pictureOut[0]);
3296     statusCode = GetDIBits(hdc, bmpbt, 1, 1, pictureOut, &bi, DIB_RGB_COLORS);
3297     ok(statusCode, "Failed to call GetDIBits. Status code: %d.\n", statusCode);
3298     ok((char)pictureOut[0] == 2, "Bottom-up -> bottom-up: first pixel should be 2 but was %d.\n", (char)pictureOut[0]);
3299     /*Check both scanlines.*/
3300     statusCode = GetDIBits(hdc, bmptb, 0, 2, pictureOut, &bi, DIB_RGB_COLORS);
3301     ok(statusCode, "Failed to call GetDIBits. Status code: %d.\n", statusCode);
3302     ok((char)pictureOut[0] == 2, "Top-down -> bottom-up: first scanline should be 2 but was %d.\n", (char)pictureOut[0]);
3303     ok((char)pictureOut[1] == 0, "Top-down -> bottom-up: second scanline should be 0 but was %d.\n", (char)pictureOut[0]);
3304     statusCode = GetDIBits(hdc, bmpbt, 0, 2, pictureOut, &bi, DIB_RGB_COLORS);
3305     ok(statusCode, "Failed to call GetDIBits. Status code: %d.\n", statusCode);
3306     ok((char)pictureOut[0] == 0, "Bottom up -> bottom-up: first scanline should be 0 but was %d.\n", (char)pictureOut[0]);
3307     ok((char)pictureOut[1] == 2, "Bottom up -> bottom-up: second scanline should be 2 but was %d.\n", (char)pictureOut[0]);
3308
3309     /*Make destination bitmap top-down.*/
3310     bi.bmiHeader.biHeight = -2;
3311     statusCode = GetDIBits(hdc, bmpbt, 0, 1, pictureOut, &bi, DIB_RGB_COLORS);
3312     ok(statusCode, "Failed to call GetDIBits. Status code: %d.\n", statusCode);
3313     ok((char)pictureOut[0] == 0, "Bottom-up -> top-down: first pixel should be 0 but was %d.\n", (char)pictureOut[0]);
3314     statusCode = GetDIBits(hdc, bmptb, 0, 1, pictureOut, &bi, DIB_RGB_COLORS);
3315     ok(statusCode, "Failed to call GetDIBits. Status code: %d.\n", statusCode);
3316     ok((char)pictureOut[0] == 2, "Top-down -> top-down: first pixel should be 2 but was %d.\n", (char)pictureOut[0]);
3317     /*Check second scanline.*/
3318     statusCode = GetDIBits(hdc, bmptb, 1, 1, pictureOut, &bi, DIB_RGB_COLORS);
3319     ok(statusCode, "Failed to call GetDIBits. Status code: %d.\n", statusCode);
3320     ok((char)pictureOut[0] == 0, "Top-down -> bottom-up: first pixel should be 0 but was %d.\n", (char)pictureOut[0]);
3321     statusCode = GetDIBits(hdc, bmpbt, 1, 1, pictureOut, &bi, DIB_RGB_COLORS);
3322     ok(statusCode, "Failed to call GetDIBits. Status code: %d.\n", statusCode);
3323     ok((char)pictureOut[0] == 2, "Top-down -> bottom-up: first pixel should be 2 but was %d.\n", (char)pictureOut[0]);
3324     /*Check both scanlines.*/
3325     statusCode = GetDIBits(hdc, bmptb, 0, 2, pictureOut, &bi, DIB_RGB_COLORS);
3326     ok(statusCode, "Failed to call GetDIBits. Status code: %d.\n", statusCode);
3327     ok((char)pictureOut[0] == 0, "Top-down -> top-down: first scanline should be 0 but was %d.\n", (char)pictureOut[0]);
3328     ok((char)pictureOut[1] == 2, "Top-down -> top-down: second scanline should be 2 but was %d.\n", (char)pictureOut[0]);
3329     statusCode = GetDIBits(hdc, bmpbt, 0, 2, pictureOut, &bi, DIB_RGB_COLORS);
3330     ok(statusCode, "Failed to call GetDIBits. Status code: %d.\n", statusCode);
3331     ok((char)pictureOut[0] == 2, "Bottom up -> top-down: first scanline should be 2 but was %d.\n", (char)pictureOut[0]);
3332     ok((char)pictureOut[1] == 0, "Bottom up -> top-down: second scanline should be 0 but was %d.\n", (char)pictureOut[0]);
3333
3334     DeleteObject(bmpbt);
3335     DeleteObject(bmptb);
3336 }
3337
3338 static void test_GetSetDIBits_rtl(void)
3339 {
3340     HDC hdc, hdc_mem;
3341     HBITMAP bitmap, orig_bitmap;
3342     BITMAPINFO info;
3343     int ret;
3344     DWORD bits_1[8 * 8], bits_2[8 * 8];
3345
3346     if(!pSetLayout)
3347     {
3348         win_skip("Don't have SetLayout\n");
3349         return;
3350     }
3351
3352     hdc = GetDC( NULL );
3353     hdc_mem = CreateCompatibleDC( hdc );
3354     pSetLayout( hdc_mem, LAYOUT_LTR );
3355
3356     bitmap = CreateCompatibleBitmap( hdc, 8, 8 );
3357     orig_bitmap = SelectObject( hdc_mem, bitmap );
3358     SetPixel( hdc_mem, 0, 0, RGB(0xff, 0, 0) );
3359     SelectObject( hdc_mem, orig_bitmap );
3360
3361     info.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
3362     info.bmiHeader.biWidth = 8;
3363     info.bmiHeader.biHeight = 8;
3364     info.bmiHeader.biPlanes = 1;
3365     info.bmiHeader.biBitCount = 32;
3366     info.bmiHeader.biCompression = BI_RGB;
3367
3368     /* First show that GetDIBits ignores the layout mode. */
3369
3370     ret = GetDIBits( hdc_mem, bitmap, 0, 8, bits_1, &info, DIB_RGB_COLORS );
3371     ok(ret == 8, "got %d\n", ret);
3372     ok(bits_1[56] == 0xff0000, "got %08x\n", bits_1[56]); /* check we have a red pixel */
3373
3374     pSetLayout( hdc_mem, LAYOUT_RTL );
3375
3376     ret = GetDIBits( hdc_mem, bitmap, 0, 8, bits_2, &info, DIB_RGB_COLORS );
3377     ok(ret == 8, "got %d\n", ret);
3378
3379     ok(!memcmp( bits_1, bits_2, sizeof(bits_1) ), "bits differ\n");
3380
3381     /* Now to show that SetDIBits also ignores the mode, we perform a SetDIBits
3382        followed by a GetDIBits and show that the bits remain unchanged. */
3383
3384     pSetLayout( hdc_mem, LAYOUT_LTR );
3385
3386     ret = SetDIBits( hdc_mem, bitmap, 0, 8, bits_1, &info, DIB_RGB_COLORS );
3387     ok(ret == 8, "got %d\n", ret);
3388     ret = GetDIBits( hdc_mem, bitmap, 0, 8, bits_2, &info, DIB_RGB_COLORS );
3389     ok(ret == 8, "got %d\n", ret);
3390     ok(!memcmp( bits_1, bits_2, sizeof(bits_1) ), "bits differ\n");
3391
3392     pSetLayout( hdc_mem, LAYOUT_RTL );
3393
3394     ret = SetDIBits( hdc_mem, bitmap, 0, 8, bits_1, &info, DIB_RGB_COLORS );
3395     ok(ret == 8, "got %d\n", ret);
3396     ret = GetDIBits( hdc_mem, bitmap, 0, 8, bits_2, &info, DIB_RGB_COLORS );
3397     ok(ret == 8, "got %d\n", ret);
3398     ok(!memcmp( bits_1, bits_2, sizeof(bits_1) ), "bits differ\n");
3399
3400     DeleteObject( bitmap );
3401     DeleteDC( hdc_mem );
3402     ReleaseDC( NULL, hdc );
3403 }
3404
3405 static void test_GetDIBits_scanlines(void)
3406 {
3407     char bmi_buf[ FIELD_OFFSET( BITMAPINFO, bmiColors[256] ) ];
3408     BITMAPINFO *info = (BITMAPINFO *)bmi_buf;
3409     DWORD *dib_bits;
3410     HDC hdc = GetDC( NULL );
3411     HBITMAP dib;
3412     DWORD data[128], inverted_bits[64];
3413     int i, ret;
3414
3415     memset( info, 0, sizeof(bmi_buf) );
3416
3417     info->bmiHeader.biSize        = sizeof(info->bmiHeader);
3418     info->bmiHeader.biWidth       = 8;
3419     info->bmiHeader.biHeight      = 8;
3420     info->bmiHeader.biPlanes      = 1;
3421     info->bmiHeader.biBitCount    = 32;
3422     info->bmiHeader.biCompression = BI_RGB;
3423
3424     dib = CreateDIBSection( NULL, info, DIB_RGB_COLORS, (void**)&dib_bits, NULL, 0 );
3425
3426     for (i = 0; i < 64; i++)
3427     {
3428         dib_bits[i] = i;
3429         inverted_bits[56 - (i & ~7) + (i & 7)] = i;
3430     }
3431
3432     /* b-u -> b-u */
3433
3434     memset( data, 0xaa, sizeof(data) );
3435
3436     ret = GetDIBits( hdc, dib, 0, 8, data, info, DIB_RGB_COLORS );
3437     ok( ret == 8, "got %d\n", ret );
3438     ok( !memcmp( data, dib_bits, 64 * 4 ), "bits differ\n");
3439     memset( data, 0xaa, sizeof(data) );
3440
3441     ret = GetDIBits( hdc, dib, 1, 5, data, info, DIB_RGB_COLORS );
3442     ok( ret == 5, "got %d\n", ret );
3443     ok( !memcmp( data, dib_bits + 8, 40 * 4 ), "bits differ\n");
3444     for (i = 40; i < 64; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3445     memset( data, 0xaa, sizeof(data) );
3446
3447     ret = GetDIBits( hdc, dib, 1, 12, data, info, DIB_RGB_COLORS );
3448     ok( ret == 7, "got %d\n", ret );
3449     ok( !memcmp( data, dib_bits + 8, 56 * 4 ), "bits differ\n");
3450     for (i = 56; i < 64; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3451     memset( data, 0xaa, sizeof(data) );
3452
3453     ret = GetDIBits( hdc, dib, 9, 12, data, info, DIB_RGB_COLORS );
3454     ok( ret == 1, "got %d\n", ret );
3455     for (i = 0; i < 64; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3456     memset( data, 0xaa, sizeof(data) );
3457
3458     info->bmiHeader.biHeight = 16;
3459     ret = GetDIBits( hdc, dib, 1, 12, data, info, DIB_RGB_COLORS );
3460     ok( ret == 5, "got %d\n", ret );
3461     for (i = 0; i < 56; i++) ok( data[i] == 0, "%d: got %08x\n", i, data[i] );
3462     ok( !memcmp( data + 56, dib_bits, 40 * 4 ), "bits differ\n");
3463     for (i = 96; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3464     memset( data, 0xaa, sizeof(data) );
3465
3466     ret = GetDIBits( hdc, dib, 2, 12, data, info, DIB_RGB_COLORS );
3467     ok( ret == 6, "got %d\n", ret );
3468     for (i = 0; i < 48; i++) ok( data[i] == 0, "%d: got %08x\n", i, data[i] );
3469     ok( !memcmp( data + 48, dib_bits, 48 * 4 ), "bits differ\n");
3470     for (i = 96; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3471     memset( data, 0xaa, sizeof(data) );
3472
3473     ret = GetDIBits( hdc, dib, 2, 3, data, info, DIB_RGB_COLORS );
3474     ok( ret == 0, "got %d\n", ret );
3475     for (i = 0; i < 24; i++) ok( data[i] == 0, "%d: got %08x\n", i, data[i] );
3476     for (i = 24; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3477     memset( data, 0xaa, sizeof(data) );
3478
3479     info->bmiHeader.biHeight = 5;
3480     ret = GetDIBits( hdc, dib, 1, 2, data, info, DIB_RGB_COLORS );
3481     ok( ret == 2, "got %d\n", ret );
3482     ok( !memcmp( data, dib_bits + 32, 16 * 4 ), "bits differ\n");
3483     for (i = 16; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3484     memset( data, 0xaa, sizeof(data) );
3485
3486     /* b-u -> t-d */
3487
3488     info->bmiHeader.biHeight = -8;
3489     ret = GetDIBits( hdc, dib, 0, 8, data, info, DIB_RGB_COLORS );
3490     ok( ret == 8, "got %d\n", ret );
3491     ok( !memcmp( data, inverted_bits, 64 * 4 ), "bits differ\n");
3492     memset( data, 0xaa, sizeof(data) );
3493
3494     ret = GetDIBits( hdc, dib, 1, 5, data, info, DIB_RGB_COLORS );
3495     ok( ret == 5, "got %d\n", ret );
3496     ok( !memcmp( data, inverted_bits + 16, 40 * 4 ), "bits differ\n");
3497     for (i = 40; i < 64; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3498     memset( data, 0xaa, sizeof(data) );
3499
3500     ret = GetDIBits( hdc, dib, 1, 12, data, info, DIB_RGB_COLORS );
3501     ok( ret == 7, "got %d\n", ret );
3502     ok( !memcmp( data, inverted_bits, 56 * 4 ), "bits differ\n");
3503     for (i = 56; i < 64; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3504     memset( data, 0xaa, sizeof(data) );
3505
3506     ret = GetDIBits( hdc, dib, 4, 12, data, info, DIB_RGB_COLORS );
3507     ok( ret == 4, "got %d\n", ret );
3508     ok( !memcmp( data, inverted_bits, 32 * 4 ), "bits differ\n");
3509     for (i = 32; i < 64; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3510     memset( data, 0xaa, sizeof(data) );
3511
3512     ret = GetDIBits( hdc, dib, 3, 12, data, info, DIB_RGB_COLORS );
3513     ok( ret == 5, "got %d\n", ret );
3514     ok( !memcmp( data, inverted_bits, 40 * 4 ), "bits differ\n");
3515     for (i = 40; i < 64; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3516     memset( data, 0xaa, sizeof(data) );
3517
3518     ret = GetDIBits( hdc, dib, 3, 13, data, info, DIB_RGB_COLORS );
3519     ok( ret == 5, "got %d\n", ret );
3520     ok( !memcmp( data, inverted_bits, 40 * 4 ), "bits differ\n");
3521     for (i = 40; i < 64; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3522     memset( data, 0xaa, sizeof(data) );
3523
3524     info->bmiHeader.biHeight = -16;
3525     ret = GetDIBits( hdc, dib, 0, 16, data, info, DIB_RGB_COLORS );
3526     ok( ret == 8, "got %d\n", ret );
3527     ok( !memcmp( data, inverted_bits, 64 * 4 ), "bits differ\n");
3528     for (i = 64; i < 128; i++) ok( data[i] == 0, "%d: got %08x\n", i, data[i] );
3529     memset( data, 0xaa, sizeof(data) );
3530
3531     ret = GetDIBits( hdc, dib, 1, 12, data, info, DIB_RGB_COLORS );
3532     ok( ret == 5, "got %d\n", ret );
3533     ok( !memcmp( data, inverted_bits + 24, 40 * 4 ), "bits differ\n");
3534     for (i = 40; i < 96; i++) ok( data[i] == 0, "%d: got %08x\n", i, data[i] );
3535     for (i = 96; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3536     memset( data, 0xaa, sizeof(data) );
3537
3538     ret = GetDIBits( hdc, dib, 4, 12, data, info, DIB_RGB_COLORS );
3539     ok( ret == 8, "got %d\n", ret );
3540     ok( !memcmp( data, inverted_bits, 64 * 4 ), "bits differ\n");
3541     for (i = 64; i < 96; i++) ok( data[i] == 0, "%d: got %08x\n", i, data[i] );
3542     for (i = 96; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3543     memset( data, 0xaa, sizeof(data) );
3544
3545     ret = GetDIBits( hdc, dib, 5, 12, data, info, DIB_RGB_COLORS );
3546     ok( ret == 8, "got %d\n", ret );
3547     ok( !memcmp( data, inverted_bits, 64 * 4 ), "bits differ\n");
3548     for (i = 64; i < 88; i++) ok( data[i] == 0, "%d: got %08x\n", i, data[i] );
3549     for (i = 88; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3550     memset( data, 0xaa, sizeof(data) );
3551
3552     ret = GetDIBits( hdc, dib, 9, 12, data, info, DIB_RGB_COLORS );
3553     ok( ret == 7, "got %d\n", ret );
3554     ok( !memcmp( data, inverted_bits, 56 * 4 ), "bits differ\n");
3555     for (i = 56; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3556     memset( data, 0xaa, sizeof(data) );
3557
3558     ret = GetDIBits( hdc, dib, 18, 12, data, info, DIB_RGB_COLORS );
3559     ok( ret == 1, "got %d\n", ret );
3560     for (i = 0; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3561     memset( data, 0xaa, sizeof(data) );
3562
3563     info->bmiHeader.biHeight = -5;
3564     ret = GetDIBits( hdc, dib, 1, 2, data, info, DIB_RGB_COLORS );
3565     ok( ret == 2, "got %d\n", ret );
3566     ok( !memcmp( data, inverted_bits + 16, 16 * 4 ), "bits differ\n");
3567     for (i = 16; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3568     memset( data, 0xaa, sizeof(data) );
3569
3570     DeleteObject( dib );
3571
3572     info->bmiHeader.biSize        = sizeof(info->bmiHeader);
3573     info->bmiHeader.biWidth       = 8;
3574     info->bmiHeader.biHeight      = -8;
3575     info->bmiHeader.biPlanes      = 1;
3576     info->bmiHeader.biBitCount    = 32;
3577     info->bmiHeader.biCompression = BI_RGB;
3578
3579     dib = CreateDIBSection( NULL, info, DIB_RGB_COLORS, (void**)&dib_bits, NULL, 0 );
3580
3581     for (i = 0; i < 64; i++) dib_bits[i] = i;
3582
3583     /* t-d -> t-d */
3584
3585     info->bmiHeader.biHeight = -8;
3586     ret = GetDIBits( hdc, dib, 0, 8, data, info, DIB_RGB_COLORS );
3587     ok( ret == 8, "got %d\n", ret );
3588     ok( !memcmp( data, dib_bits, 64 * 4 ), "bits differ\n");
3589     memset( data, 0xaa, sizeof(data) );
3590
3591     ret = GetDIBits( hdc, dib, 1, 5, data, info, DIB_RGB_COLORS );
3592     ok( ret == 5, "got %d\n", ret );
3593     ok( !memcmp( data, dib_bits + 16, 40 * 4 ), "bits differ\n");
3594     for (i = 40; i < 64; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3595     memset( data, 0xaa, sizeof(data) );
3596
3597     ret = GetDIBits( hdc, dib, 1, 12, data, info, DIB_RGB_COLORS );
3598     ok( ret == 7, "got %d\n", ret );
3599     ok( !memcmp( data, dib_bits, 56 * 4 ), "bits differ\n");
3600     for (i = 56; i < 64; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3601     memset( data, 0xaa, sizeof(data) );
3602
3603     ret = GetDIBits( hdc, dib, 4, 12, data, info, DIB_RGB_COLORS );
3604     ok( ret == 4, "got %d\n", ret );
3605     ok( !memcmp( data, dib_bits, 32 * 4 ), "bits differ\n");
3606     for (i = 32; i < 64; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3607     memset( data, 0xaa, sizeof(data) );
3608
3609     ret = GetDIBits( hdc, dib, 3, 12, data, info, DIB_RGB_COLORS );
3610     ok( ret == 5, "got %d\n", ret );
3611     ok( !memcmp( data, dib_bits, 40 * 4 ), "bits differ\n");
3612     for (i = 40; i < 64; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3613     memset( data, 0xaa, sizeof(data) );
3614
3615     ret = GetDIBits( hdc, dib, 3, 13, data, info, DIB_RGB_COLORS );
3616     ok( ret == 5, "got %d\n", ret );
3617     ok( !memcmp( data, dib_bits, 40 * 4 ), "bits differ\n");
3618     for (i = 40; i < 64; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3619     memset( data, 0xaa, sizeof(data) );
3620
3621     info->bmiHeader.biHeight = -16;
3622     ret = GetDIBits( hdc, dib, 0, 16, data, info, DIB_RGB_COLORS );
3623     ok( ret == 8, "got %d\n", ret );
3624     ok( !memcmp( data, dib_bits, 64 * 4 ), "bits differ\n");
3625     for (i = 64; i < 128; i++) ok( data[i] == 0, "%d: got %08x\n", i, data[i] );
3626     memset( data, 0xaa, sizeof(data) );
3627
3628     ret = GetDIBits( hdc, dib, 1, 12, data, info, DIB_RGB_COLORS );
3629     ok( ret == 5, "got %d\n", ret );
3630     ok( !memcmp( data, dib_bits + 24, 40 * 4 ), "bits differ\n");
3631     for (i = 40; i < 96; i++) ok( data[i] == 0, "%d: got %08x\n", i, data[i] );
3632     for (i = 96; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3633     memset( data, 0xaa, sizeof(data) );
3634
3635     ret = GetDIBits( hdc, dib, 4, 12, data, info, DIB_RGB_COLORS );
3636     ok( ret == 8, "got %d\n", ret );
3637     ok( !memcmp( data, dib_bits, 64 * 4 ), "bits differ\n");
3638     for (i = 64; i < 96; i++) ok( data[i] == 0, "%d: got %08x\n", i, data[i] );
3639     for (i = 96; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3640     memset( data, 0xaa, sizeof(data) );
3641
3642     ret = GetDIBits( hdc, dib, 5, 12, data, info, DIB_RGB_COLORS );
3643     ok( ret == 8, "got %d\n", ret );
3644     ok( !memcmp( data, dib_bits, 64 * 4 ), "bits differ\n");
3645     for (i = 64; i < 88; i++) ok( data[i] == 0, "%d: got %08x\n", i, data[i] );
3646     for (i = 88; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3647     memset( data, 0xaa, sizeof(data) );
3648
3649     ret = GetDIBits( hdc, dib, 9, 12, data, info, DIB_RGB_COLORS );
3650     ok( ret == 7, "got %d\n", ret );
3651     ok( !memcmp( data, dib_bits, 56 * 4 ), "bits differ\n");
3652     for (i = 56; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3653     memset( data, 0xaa, sizeof(data) );
3654
3655     info->bmiHeader.biHeight = -5;
3656     ret = GetDIBits( hdc, dib, 1, 2, data, info, DIB_RGB_COLORS );
3657     ok( ret == 2, "got %d\n", ret );
3658     ok( !memcmp( data, dib_bits + 16, 16 * 4 ), "bits differ\n");
3659     for (i = 16; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3660     memset( data, 0xaa, sizeof(data) );
3661
3662
3663     /* t-d -> b-u */
3664
3665     info->bmiHeader.biHeight = 8;
3666
3667     ret = GetDIBits( hdc, dib, 0, 8, data, info, DIB_RGB_COLORS );
3668     ok( ret == 8, "got %d\n", ret );
3669     ok( !memcmp( data, inverted_bits, 64 * 4 ), "bits differ\n");
3670     memset( data, 0xaa, sizeof(data) );
3671
3672     ret = GetDIBits( hdc, dib, 1, 5, data, info, DIB_RGB_COLORS );
3673     ok( ret == 5, "got %d\n", ret );
3674     ok( !memcmp( data, inverted_bits + 8, 40 * 4 ), "bits differ\n");
3675     for (i = 40; i < 64; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3676     memset( data, 0xaa, sizeof(data) );
3677
3678     ret = GetDIBits( hdc, dib, 1, 12, data, info, DIB_RGB_COLORS );
3679     ok( ret == 7, "got %d\n", ret );
3680     ok( !memcmp( data, inverted_bits + 8, 56 * 4 ), "bits differ\n");
3681     for (i = 56; i < 64; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3682     memset( data, 0xaa, sizeof(data) );
3683
3684     ret = GetDIBits( hdc, dib, 9, 12, data, info, DIB_RGB_COLORS );
3685     ok( ret == 1, "got %d\n", ret );
3686     for (i = 0; i < 64; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3687     memset( data, 0xaa, sizeof(data) );
3688
3689     info->bmiHeader.biHeight = 16;
3690     ret = GetDIBits( hdc, dib, 1, 12, data, info, DIB_RGB_COLORS );
3691     ok( ret == 5, "got %d\n", ret );
3692     for (i = 0; i < 56; i++) ok( data[i] == 0, "%d: got %08x\n", i, data[i] );
3693     ok( !memcmp( data + 56, inverted_bits, 40 * 4 ), "bits differ\n");
3694     for (i = 96; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3695     memset( data, 0xaa, sizeof(data) );
3696
3697     ret = GetDIBits( hdc, dib, 2, 12, data, info, DIB_RGB_COLORS );
3698     ok( ret == 6, "got %d\n", ret );
3699     for (i = 0; i < 48; i++) ok( data[i] == 0, "%d: got %08x\n", i, data[i] );
3700     ok( !memcmp( data + 48, inverted_bits, 48 * 4 ), "bits differ\n");
3701     for (i = 96; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3702     memset( data, 0xaa, sizeof(data) );
3703
3704     ret = GetDIBits( hdc, dib, 2, 3, data, info, DIB_RGB_COLORS );
3705     ok( ret == 0, "got %d\n", ret );
3706     for (i = 0; i < 24; i++) ok( data[i] == 0, "%d: got %08x\n", i, data[i] );
3707     for (i = 24; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3708     memset( data, 0xaa, sizeof(data) );
3709
3710     info->bmiHeader.biHeight = 5;
3711     ret = GetDIBits( hdc, dib, 1, 2, data, info, DIB_RGB_COLORS );
3712     ok( ret == 2, "got %d\n", ret );
3713     ok( !memcmp( data, inverted_bits + 32, 16 * 4 ), "bits differ\n");
3714     for (i = 16; i < 128; i++) ok( data[i] == 0xaaaaaaaa, "%d: got %08x\n", i, data[i] );
3715     memset( data, 0xaa, sizeof(data) );
3716
3717     DeleteObject( dib );
3718
3719     ReleaseDC( NULL, hdc );
3720 }
3721
3722
3723 static void test_SetDIBits(void)
3724 {
3725     char bmi_buf[ FIELD_OFFSET( BITMAPINFO, bmiColors[256] ) ];
3726     BITMAPINFO *info = (BITMAPINFO *)bmi_buf;
3727     DWORD *dib_bits;
3728     HDC hdc = GetDC( NULL );
3729     DWORD data[128], inverted_data[128];
3730     HBITMAP dib;
3731     int i, ret;
3732
3733     memset( info, 0, sizeof(bmi_buf) );
3734
3735     info->bmiHeader.biSize        = sizeof(info->bmiHeader);
3736     info->bmiHeader.biWidth       = 8;
3737     info->bmiHeader.biHeight      = 8;
3738     info->bmiHeader.biPlanes      = 1;
3739     info->bmiHeader.biBitCount    = 32;
3740     info->bmiHeader.biCompression = BI_RGB;
3741
3742     dib = CreateDIBSection( NULL, info, DIB_RGB_COLORS, (void**)&dib_bits, NULL, 0 );
3743     memset( dib_bits, 0xaa, 64 * 4 );
3744
3745     for (i = 0; i < 128; i++)
3746     {
3747         data[i] = i;
3748         inverted_data[120 - (i & ~7) + (i & 7)] = i;
3749     }
3750
3751     /* b-u -> b-u */
3752
3753     ret = SetDIBits( hdc, dib, 0, 8, data, info, DIB_RGB_COLORS );
3754     ok( ret == 8, "got %d\n", ret );
3755     ok( !memcmp( dib_bits, data, 64 * 4 ), "bits differ\n");
3756     memset( dib_bits, 0xaa, 64 * 4 );
3757
3758     ret = SetDIBits( hdc, dib, 1, 5, data, info, DIB_RGB_COLORS );
3759     ok( ret == 5, "got %d\n", ret );
3760     for (i = 0; i < 8; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3761     ok( !memcmp( dib_bits + 8, data, 40 * 4 ), "bits differ\n");
3762     for (i = 48; i < 64; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3763     memset( dib_bits, 0xaa, 64 * 4 );
3764
3765     /* top of dst is aligned with startscans down for the top of the src.
3766        Then starting from the bottom of src, lines rows are copied across. */
3767
3768     info->bmiHeader.biHeight = 16;
3769     ret = SetDIBits( hdc, dib, 1, 12, data, info, DIB_RGB_COLORS );
3770     ok( ret == 12, "got %d\n", ret );
3771     ok( !memcmp( dib_bits, data + 56,  40 * 4 ), "bits differ\n");
3772     for (i = 40; i < 64; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3773     memset( dib_bits, 0xaa, 64 * 4 );
3774
3775     info->bmiHeader.biHeight = 5;
3776     ret = SetDIBits( hdc, dib, 1, 2, data, info, DIB_RGB_COLORS );
3777     ok( ret == 2, "got %d\n", ret );
3778     for (i = 0; i < 32; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3779     ok( !memcmp( dib_bits + 32, data,  16 * 4 ), "bits differ\n");
3780     for (i = 48; i < 64; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3781     memset( dib_bits, 0xaa, 64 * 4 );
3782
3783     /* t-d -> b-u */
3784     info->bmiHeader.biHeight = -8;
3785     ret = SetDIBits( hdc, dib, 0, 8, data, info, DIB_RGB_COLORS );
3786     ok( ret == 8, "got %d\n", ret );
3787     ok( !memcmp( dib_bits, inverted_data + 64,  64 * 4 ), "bits differ\n");
3788     memset( dib_bits, 0xaa, 64 * 4 );
3789
3790     /* top of dst now lines up with -(abs(src_h) - startscan - lines) and
3791        we copy lines rows from the top of the src */
3792
3793     ret = SetDIBits( hdc, dib, 1, 5, data, info, DIB_RGB_COLORS );
3794     ok( ret == 5, "got %d\n", ret );
3795     for (i = 0; i < 8; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3796     ok( !memcmp( dib_bits + 8, inverted_data + 88, 40 * 4 ), "bits differ\n");
3797     for (i = 48; i < 64; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3798     memset( dib_bits, 0xaa, 64 * 4 );
3799
3800     info->bmiHeader.biHeight = -16;
3801     ret = SetDIBits( hdc, dib, 1, 12, data, info, DIB_RGB_COLORS );
3802     ok( ret == 12, "got %d\n", ret );
3803     ok( !memcmp( dib_bits, inverted_data + 88, 40 * 4 ), "bits differ\n");
3804     for (i = 40; i < 64; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3805     memset( dib_bits, 0xaa, 64 * 4 );
3806
3807     ret = SetDIBits( hdc, dib, 4, 12, data, info, DIB_RGB_COLORS );
3808     ok( ret == 12, "got %d\n", ret );
3809     ok( !memcmp( dib_bits, inverted_data + 64, 64 * 4 ), "bits differ\n");
3810     memset( dib_bits, 0xaa, 64 * 4 );
3811
3812     ret = SetDIBits( hdc, dib, 5, 12, data, info, DIB_RGB_COLORS );
3813     ok( ret == 12, "got %d\n", ret );
3814     ok( !memcmp( dib_bits, inverted_data + 56, 64 * 4 ), "bits differ\n");
3815     memset( dib_bits, 0xaa, 64 * 4 );
3816
3817     info->bmiHeader.biHeight = -5;
3818     ret = SetDIBits( hdc, dib, 1, 2, data, info, DIB_RGB_COLORS );
3819     ok( ret == 2, "got %d\n", ret );
3820     for (i = 0; i < 32; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3821     ok( !memcmp( dib_bits + 32, inverted_data + 112, 16 * 4 ), "bits differ\n");
3822     for (i = 48; i < 64; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3823     memset( dib_bits, 0xaa, 64 * 4 );
3824
3825     DeleteObject( dib );
3826
3827     info->bmiHeader.biHeight = -8;
3828
3829     dib = CreateDIBSection( NULL, info, DIB_RGB_COLORS, (void**)&dib_bits, NULL, 0 );
3830     memset( dib_bits, 0xaa, 16 * 16 * 4 );
3831
3832     /* t-d -> t-d */
3833
3834     /* like the t-d -> b-u case. */
3835
3836     ret = SetDIBits( hdc, dib, 0, 8, data, info, DIB_RGB_COLORS );
3837     ok( ret == 8, "got %d\n", ret );
3838     ok( !memcmp( dib_bits, data, 64 * 4 ), "bits differ\n");
3839     memset( dib_bits, 0xaa, 64 * 4 );
3840
3841     ret = SetDIBits( hdc, dib, 1, 5, data, info, DIB_RGB_COLORS );
3842     ok( ret == 5, "got %d\n", ret );
3843     for (i = 0; i < 16; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3844     ok( !memcmp( dib_bits + 16, data, 40 * 4 ), "bits differ\n");
3845     for (i = 56; i < 64; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3846     memset( dib_bits, 0xaa, 64 * 4 );
3847
3848     info->bmiHeader.biHeight = -16;
3849     ret = SetDIBits( hdc, dib, 1, 12, data, info, DIB_RGB_COLORS );
3850     ok( ret == 12, "got %d\n", ret );
3851     for (i = 0; i < 24; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3852     ok( !memcmp( dib_bits + 24, data,  40 * 4 ), "bits differ\n");
3853     memset( dib_bits, 0xaa, 64 * 4 );
3854
3855     info->bmiHeader.biHeight = -5;
3856     ret = SetDIBits( hdc, dib, 1, 2, data, info, DIB_RGB_COLORS );
3857     ok( ret == 2, "got %d\n", ret );
3858     for (i = 0; i < 16; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3859     ok( !memcmp( dib_bits + 16, data,  16 * 4 ), "bits differ\n");
3860     for (i = 32; i < 64; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3861     memset( dib_bits, 0xaa, 64 * 4 );
3862
3863     /* b-u -> t-d */
3864     /* like the b-u -> b-u case */
3865
3866     info->bmiHeader.biHeight = 8;
3867     ret = SetDIBits( hdc, dib, 0, 8, data, info, DIB_RGB_COLORS );
3868     ok( ret == 8, "got %d\n", ret );
3869     ok( !memcmp( dib_bits, inverted_data + 64, 64 * 4 ), "bits differ\n");
3870     memset( dib_bits, 0xaa, 64 * 4 );
3871
3872     ret = SetDIBits( hdc, dib, 1, 5, data, info, DIB_RGB_COLORS );
3873     ok( ret == 5, "got %d\n", ret );
3874     for (i = 0; i < 16; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3875     ok( !memcmp( dib_bits + 16, inverted_data + 88, 40 * 4 ), "bits differ\n");
3876     for (i = 56; i < 64; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3877     memset( dib_bits, 0xaa, 64 * 4 );
3878
3879     info->bmiHeader.biHeight = 16;
3880     ret = SetDIBits( hdc, dib, 1, 12, data, info, DIB_RGB_COLORS );
3881     ok( ret == 12, "got %d\n", ret );
3882     for (i = 0; i < 24; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3883     ok( !memcmp( dib_bits + 24, inverted_data + 32, 40 * 4 ), "bits differ\n");
3884     memset( dib_bits, 0xaa, 64 * 4 );
3885
3886     info->bmiHeader.biHeight = 5;
3887     ret = SetDIBits( hdc, dib, 1, 2, data, info, DIB_RGB_COLORS );
3888     ok( ret == 2, "got %d\n", ret );
3889     for (i = 0; i < 16; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3890     ok( !memcmp( dib_bits + 16, inverted_data + 112, 16 * 4 ), "bits differ\n");
3891     for (i = 32; i < 64; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
3892     memset( dib_bits, 0xaa, 64 * 4 );
3893
3894     DeleteObject( dib );
3895     ReleaseDC( NULL, hdc );
3896 }
3897
3898 static void test_SetDIBits_RLE4(void)
3899 {
3900     char bmi_buf[ FIELD_OFFSET( BITMAPINFO, bmiColors[256] ) ];
3901     BITMAPINFO *info = (BITMAPINFO *)bmi_buf;
3902     DWORD *dib_bits;
3903     HDC hdc = GetDC( NULL );
3904     BYTE rle4_data[26] = { 0x03, 0x52, 0x07, 0x68, 0x00, 0x00,     /* 5, 2, 5, 6, 8, 6, 8, 6, (8, 6,) <eol> */
3905                            0x00, 0x03, 0x14, 0x50, 0x00, 0x05,
3906                            0x79, 0xfd, 0xb0, 0x00, 0x00, 0x00,     /* 1, 4, 5, 7, 9, f, d, b <pad> <eol> */
3907                            0x00, 0x02, 0x01, 0x02, 0x05, 0x87,     /* dx=1, dy=2, 8, 7, 8, 7, 8 */
3908                            0x00, 0x01 };                           /* <eod> */
3909     HBITMAP dib;
3910     int i, ret;
3911     DWORD bottom_up[64] = { 0x00050505, 0x00020202, 0x00050505, 0x00060606, 0x00080808, 0x00060606, 0x00080808, 0x00060606,
3912                             0x00010101, 0x00040404, 0x00050505, 0x00070707, 0x00090909, 0x000f0f0f, 0x000d0d0d, 0x000b0b0b,
3913                             0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
3914                             0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
3915                             0xaaaaaaaa, 0x00080808, 0x00070707, 0x00080808, 0x00070707, 0x00080808, 0xaaaaaaaa, 0xaaaaaaaa,
3916                             0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
3917                             0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
3918                             0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa };
3919
3920     memset( info, 0, sizeof(bmi_buf) );
3921
3922     info->bmiHeader.biSize        = sizeof(info->bmiHeader);
3923     info->bmiHeader.biWidth       = 8;
3924     info->bmiHeader.biHeight      = 8;
3925     info->bmiHeader.biPlanes      = 1;
3926     info->bmiHeader.biBitCount    = 32;
3927     info->bmiHeader.biCompression = BI_RGB;
3928
3929     dib = CreateDIBSection( NULL, info, DIB_RGB_COLORS, (void**)&dib_bits, NULL, 0 );
3930     memset( dib_bits, 0xaa, 64 * 4 );
3931
3932     info->bmiHeader.biBitCount    = 4;
3933     info->bmiHeader.biCompression = BI_RLE4;
3934     info->bmiHeader.biSizeImage   = sizeof(rle4_data);
3935
3936     for (i = 0; i < 16; i++)
3937     {
3938         info->bmiColors[i].rgbRed      = i;
3939         info->bmiColors[i].rgbGreen    = i;
3940         info->bmiColors[i].rgbBlue     = i;
3941         info->bmiColors[i].rgbReserved = 0;
3942     }
3943
3944     ret = SetDIBits( hdc, dib, 0, 8, rle4_data, info, DIB_RGB_COLORS );
3945     ok( ret == 8, "got %d\n", ret );
3946     ok( !memcmp( dib_bits, bottom_up, sizeof(bottom_up) ), "bits differ\n" );
3947     memset( dib_bits, 0xaa, 64 * 4 );
3948
3949     DeleteObject( dib );
3950     ReleaseDC( NULL, hdc );
3951 }
3952
3953 static void test_SetDIBits_RLE8(void)
3954 {
3955     char bmi_buf[ FIELD_OFFSET( BITMAPINFO, bmiColors[256] ) ];
3956     BITMAPINFO *info = (BITMAPINFO *)bmi_buf;
3957     DWORD *dib_bits;
3958     HDC hdc = GetDC( NULL );
3959     BYTE rle8_data[20] = { 0x03, 0x02, 0x04, 0xf0, 0x00, 0x00,     /* 2, 2, 2, f0, f0, f0, f0, <eol> */
3960                            0x00, 0x03, 0x04, 0x05, 0x06, 0x00,     /* 4, 5, 6, <pad> */
3961                            0x00, 0x02, 0x01, 0x02, 0x05, 0x80,     /* dx=1, dy=2, 80, 80, 80, 80, (80) */
3962                            0x00, 0x01 };                           /* <eod> */
3963     HBITMAP dib;
3964     int i, ret;
3965     DWORD bottom_up[64] = { 0x00020202, 0x00020202, 0x00020202, 0x00f0f0f0, 0x00f0f0f0, 0x00f0f0f0, 0x00f0f0f0, 0xaaaaaaaa,
3966                             0x00040404, 0x00050505, 0x00060606, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
3967                             0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
3968                             0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0x00808080, 0x00808080, 0x00808080, 0x00808080,
3969                             0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
3970                             0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
3971                             0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
3972                             0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa };
3973     DWORD top_down[64]  = { 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
3974                             0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
3975                             0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
3976                             0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
3977                             0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0x00808080, 0x00808080, 0x00808080, 0x00808080,
3978                             0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
3979                             0x00040404, 0x00050505, 0x00060606, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa, 0xaaaaaaaa,
3980                             0x00020202, 0x00020202, 0x00020202, 0x00f0f0f0, 0x00f0f0f0, 0x00f0f0f0, 0x00f0f0f0, 0xaaaaaaaa };
3981
3982     memset( info, 0, sizeof(bmi_buf) );
3983
3984     info->bmiHeader.biSize        = sizeof(info->bmiHeader);
3985     info->bmiHeader.biWidth       = 8;
3986     info->bmiHeader.biHeight      = 8;
3987     info->bmiHeader.biPlanes      = 1;
3988     info->bmiHeader.biBitCount    = 32;
3989     info->bmiHeader.biCompression = BI_RGB;
3990
3991     dib = CreateDIBSection( NULL, info, DIB_RGB_COLORS, (void**)&dib_bits, NULL, 0 );
3992     memset( dib_bits, 0xaa, 64 * 4 );
3993
3994     info->bmiHeader.biBitCount    = 8;
3995     info->bmiHeader.biCompression = BI_RLE8;
3996     info->bmiHeader.biSizeImage   = sizeof(rle8_data);
3997
3998     for (i = 0; i < 256; i++)
3999     {
4000         info->bmiColors[i].rgbRed      = i;
4001         info->bmiColors[i].rgbGreen    = i;
4002         info->bmiColors[i].rgbBlue     = i;
4003         info->bmiColors[i].rgbReserved = 0;
4004     }
4005
4006     ret = SetDIBits( hdc, dib, 0, 8, rle8_data, info, DIB_RGB_COLORS );
4007     ok( ret == 8, "got %d\n", ret );
4008     ok( !memcmp( dib_bits, bottom_up, sizeof(bottom_up) ), "bits differ\n");
4009     memset( dib_bits, 0xaa, 64 * 4 );
4010
4011     /* startscan and lines are ignored, unless lines == 0 */
4012     ret = SetDIBits( hdc, dib, 1, 8, rle8_data, info, DIB_RGB_COLORS );
4013     ok( ret == 8, "got %d\n", ret );
4014     ok( !memcmp( dib_bits, bottom_up, sizeof(bottom_up) ), "bits differ\n");
4015     memset( dib_bits, 0xaa, 64 * 4 );
4016
4017     ret = SetDIBits( hdc, dib, 1, 1, rle8_data, info, DIB_RGB_COLORS );
4018     ok( ret == 8, "got %d\n", ret );
4019     ok( !memcmp( dib_bits, bottom_up, sizeof(bottom_up) ), "bits differ\n");
4020     memset( dib_bits, 0xaa, 64 * 4 );
4021
4022     ret = SetDIBits( hdc, dib, 1, 0, rle8_data, info, DIB_RGB_COLORS );
4023     ok( ret == 0, "got %d\n", ret );
4024     for (i = 0; i < 64; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
4025     memset( dib_bits, 0xaa, 64 * 4 );
4026
4027     /* reduce width to 4, left-hand side of dst is touched. */
4028     info->bmiHeader.biWidth = 4;
4029     ret = SetDIBits( hdc, dib, 0, 8, rle8_data, info, DIB_RGB_COLORS );
4030     ok( ret == 8, "got %d\n", ret );
4031     for (i = 0; i < 64; i++)
4032     {
4033         DWORD expect = (i & 4) ? 0xaaaaaaaa : bottom_up[i];
4034         ok( dib_bits[i] == expect, "%d: got %08x\n", i, dib_bits[i] );
4035     }
4036     memset( dib_bits, 0xaa, 64 * 4 );
4037
4038     /* Show that the top lines are aligned by adjusting the height of the src */
4039
4040     /* reduce the height to 4 -> top 4 lines of dst are touched (corresponding to last half of the bits). */
4041     info->bmiHeader.biWidth  = 8;
4042     info->bmiHeader.biHeight = 4;
4043     ret = SetDIBits( hdc, dib, 0, 8, rle8_data, info, DIB_RGB_COLORS );
4044     ok( ret == 4, "got %d\n", ret );
4045     for (i = 0; i < 32; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
4046     ok( !memcmp( dib_bits + 32, bottom_up, 32 * 4 ), "bits differ\n");
4047     memset( dib_bits, 0xaa, 64 * 4 );
4048
4049     /* increase the height to 9 -> everything moves down one row. */
4050     info->bmiHeader.biHeight = 9;
4051     ret = SetDIBits( hdc, dib, 0, 8, rle8_data, info, DIB_RGB_COLORS );
4052     ok( ret == 9, "got %d\n", ret );
4053     ok( !memcmp( dib_bits, bottom_up + 8, 56 * 4 ), "bits differ\n");
4054     for (i = 0; i < 8; i++) ok( dib_bits[56 + i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[56 + i] );
4055     memset( dib_bits, 0xaa, 64 * 4 );
4056
4057     /* top-down compressed dibs are invalid */
4058     info->bmiHeader.biHeight = -8;
4059     SetLastError( 0xdeadbeef );
4060     ret = SetDIBits( hdc, dib, 0, 8, rle8_data, info, DIB_RGB_COLORS );
4061     ok( ret == 0, "got %d\n", ret );
4062     ok( GetLastError() == ERROR_INVALID_PARAMETER, "got %x\n", GetLastError() );
4063     DeleteObject( dib );
4064
4065     /* top-down dst */
4066
4067     info->bmiHeader.biHeight      = -8;
4068     info->bmiHeader.biBitCount    = 32;
4069     info->bmiHeader.biCompression = BI_RGB;
4070     info->bmiHeader.biSizeImage   = 0;
4071
4072     dib = CreateDIBSection( NULL, info, DIB_RGB_COLORS, (void**)&dib_bits, NULL, 0 );
4073     memset( dib_bits, 0xaa, 16 * 16 * 4 );
4074
4075     info->bmiHeader.biHeight      = 8;
4076     info->bmiHeader.biBitCount    = 8;
4077     info->bmiHeader.biCompression = BI_RLE8;
4078     info->bmiHeader.biSizeImage   = sizeof(rle8_data);
4079
4080     ret = SetDIBits( hdc, dib, 0, 8, rle8_data, info, DIB_RGB_COLORS );
4081     ok( ret == 8, "got %d\n", ret );
4082     ok( !memcmp( dib_bits, top_down, sizeof(top_down) ), "bits differ\n");
4083     memset( dib_bits, 0xaa, 64 * 4 );
4084
4085     info->bmiHeader.biHeight = 4;
4086     ret = SetDIBits( hdc, dib, 0, 8, rle8_data, info, DIB_RGB_COLORS );
4087     ok( ret == 4, "got %d\n", ret );
4088     ok( !memcmp( dib_bits, top_down + 32, 32 * 4 ), "bits differ\n");
4089     for (i = 32; i < 64; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
4090     memset( dib_bits, 0xaa, 64 * 4 );
4091
4092     info->bmiHeader.biHeight = 9;
4093     ret = SetDIBits( hdc, dib, 0, 8, rle8_data, info, DIB_RGB_COLORS );
4094     ok( ret == 9, "got %d\n", ret );
4095     for (i = 0; i < 8; i++) ok( dib_bits[i] == 0xaaaaaaaa, "%d: got %08x\n", i, dib_bits[i] );
4096     ok( !memcmp( dib_bits + 8, top_down, 56 * 4 ), "bits differ\n");
4097     memset( dib_bits, 0xaa, 64 * 4 );
4098
4099     DeleteObject( dib );
4100
4101     ReleaseDC( NULL, hdc );
4102 }
4103
4104 START_TEST(bitmap)
4105 {
4106     HMODULE hdll;
4107
4108     hdll = GetModuleHandle("gdi32.dll");
4109     pGdiAlphaBlend = (void*)GetProcAddress(hdll, "GdiAlphaBlend");
4110     pSetLayout     = (void*)GetProcAddress(hdll, "SetLayout");
4111
4112     test_createdibitmap();
4113     test_dibsections();
4114     test_dib_formats();
4115     test_mono_dibsection();
4116     test_bitmap();
4117     test_bmBits();
4118     test_GetDIBits_selected_DIB(1);
4119     test_GetDIBits_selected_DIB(4);
4120     test_GetDIBits_selected_DIB(8);
4121     test_GetDIBits_selected_DDB(TRUE);
4122     test_GetDIBits_selected_DDB(FALSE);
4123     test_GetDIBits();
4124     test_GetDIBits_BI_BITFIELDS();
4125     test_select_object();
4126     test_CreateBitmap();
4127     test_BitBlt();
4128     test_StretchBlt();
4129     test_StretchDIBits();
4130     test_GdiAlphaBlend();
4131     test_32bit_bitmap_blt();
4132     test_bitmapinfoheadersize();
4133     test_get16dibits();
4134     test_clipping();
4135     test_GetDIBits_top_down(16);
4136     test_GetDIBits_top_down(24);
4137     test_GetDIBits_top_down(32);
4138     test_GetSetDIBits_rtl();
4139     test_GetDIBits_scanlines();
4140     test_SetDIBits();
4141     test_SetDIBits_RLE4();
4142     test_SetDIBits_RLE8();
4143 }